int main(int argc, char *argv[]) { bool ret = true; dstring dynamic_dstring = DSTRING_INIT; dstring static_dstring; char static_buffer[MAX_STRING_SIZE]; sge_dstring_init(&static_dstring, static_buffer, STATIC_SIZE); printf("running all checks with a dynamic dstring\n"); ret = check_all(&dynamic_dstring); test_dstring_performance(&dynamic_dstring, 100000, "test_data"); test_dstring_performance_dynamic(100000, "test_data"); printf("%s\n", sge_dstring_get_string(&dynamic_dstring)); if (ret) { printf("\n\nrunning all checks with a static dstring of length %d\n", STATIC_SIZE); ret = check_all(&static_dstring); test_dstring_performance(&static_dstring, 100000, "test_data"); test_dstring_performance_static(100000, "test_data"); printf("%s\n", sge_dstring_get_string(&static_dstring)); } sge_dstring_free(&dynamic_dstring); return ret ? EXIT_SUCCESS : EXIT_FAILURE; }
bool binding_parse_from_string(lListElem *this_elem, lList **answer_list, dstring *string) { bool ret = true; DENTER(BINDING_LAYER, "binding_parse_from_string"); if (this_elem != NULL && string != NULL) { int amount = 0; int stepsize = 0; int firstsocket = 0; int firstcore = 0; binding_type_t type = BINDING_TYPE_NONE; dstring strategy = DSTRING_INIT; dstring socketcorelist = DSTRING_INIT; dstring error = DSTRING_INIT; if (parse_binding_parameter_string(sge_dstring_get_string(string), &type, &strategy, &amount, &stepsize, &firstsocket, &firstcore, &socketcorelist, &error) != true) { dstring parse_binding_error = DSTRING_INIT; sge_dstring_append_dstring(&parse_binding_error, &error); answer_list_add_sprintf(answer_list, STATUS_ESEMANTIC, ANSWER_QUALITY_ERROR, MSG_PARSE_XOPTIONWRONGARGUMENT_SS, "-binding", sge_dstring_get_string(&parse_binding_error)); sge_dstring_free(&parse_binding_error); ret = false; } else { lSetString(this_elem, BN_strategy, sge_dstring_get_string(&strategy)); lSetUlong(this_elem, BN_type, type); lSetUlong(this_elem, BN_parameter_socket_offset, (firstsocket >= 0) ? firstsocket : 0); lSetUlong(this_elem, BN_parameter_core_offset, (firstcore >= 0) ? firstcore : 0); lSetUlong(this_elem, BN_parameter_n, (amount >= 0) ? amount : 0); lSetUlong(this_elem, BN_parameter_striding_step_size, (stepsize >= 0) ? stepsize : 0); if (strstr(sge_dstring_get_string(&strategy), "explicit") != NULL) { lSetString(this_elem, BN_parameter_explicit, sge_dstring_get_string(&socketcorelist)); } } sge_dstring_free(&strategy); sge_dstring_free(&socketcorelist); sge_dstring_free(&error); } DRETURN(ret); }
static void sge_error_verror(sge_error_class_t* thiz, int error_type, int error_quality, const char*format, va_list ap) { sge_error_message_t *error = NULL; sge_error_t *et = (sge_error_t*)thiz->sge_error_handle; dstring ds = DSTRING_INIT; DENTER(TOP_LAYER, "sge_error_verror"); error = (sge_error_message_t*)sge_malloc(sizeof(sge_error_message_t)); error->error_quality = error_quality; error->error_type = error_type; sge_dstring_vsprintf(&ds, format, ap); error->message = strdup(sge_dstring_get_string(&ds)); error->next = NULL; sge_dstring_free(&ds); DPRINTF(("error: %s\n", error->message ? error->message : "")); if (et->first == NULL) { et->first = error; et->last = error; } else { et->last->next = error; et->last = error; } DEXIT; }
/****** shepherd_binding/create_binding_env() **************************** * NAME * create_binding_env() -- Creates SGE_BINDING env variable. * * SYNOPSIS * bool create_binding_env(hwloc_const_bitmap_t set) * * FUNCTION * Creates the SGE_BINDING environment variable. * This environment variable contains a space-separated list of * internal processor ids given as input parameter. * * INPUTS * hwloc_const_bitmap_t set - CPU set to use * * RESULT * bool - true when SGE_BINDING env var could be generated false if not * * NOTES * MT-NOTE: create_binding_env() is MT safe * *******************************************************************************/ static bool create_binding_env(hwloc_const_bitmap_t set) { bool retval = true; dstring sge_binding = DSTRING_INIT; dstring proc = DSTRING_INIT; unsigned i; bool first = true; hwloc_bitmap_foreach_begin(i, set) if (first) { first = false; sge_dstring_sprintf(&proc, "%d", i); } else { sge_dstring_sprintf(&proc, " %d", i); } sge_dstring_append_dstring(&sge_binding, &proc); hwloc_bitmap_foreach_end(); if (sge_setenv("SGE_BINDING", sge_dstring_get_string(&sge_binding)) != 1) { /* settting env var was not successful */ retval = false; shepherd_trace("create_binding_env: Couldn't set environment variable!"); } sge_dstring_free(&sge_binding); sge_dstring_free(&proc); return retval; }
void sge_worker_initialize(sge_gdi_ctx_class_t *ctx) { const u_long32 max_initial_worker_threads = ctx->get_worker_thread_count(ctx); cl_thread_settings_t* dummy_thread_p = NULL; int i; DENTER(TOP_LAYER, "sge_worker_initialize"); /* * TODO: EB: corresponding destroy function is missing during shutdown */ sge_tq_create(&Master_Task_Queue); sge_init_job_number(); sge_init_ar_id(); DPRINTF(("job/ar counter have been initialized\n")); reporting_initialize(NULL); DPRINTF(("accounting and reporting module has been initialized\n")); INFO((SGE_EVENT, MSG_QMASTER_THREADCOUNT_US, sge_u32c(max_initial_worker_threads), threadnames[WORKER_THREAD])); cl_thread_list_setup(&(Main_Control.worker_thread_pool), "thread pool"); for (i = 0; i < max_initial_worker_threads; i++) { dstring thread_name = DSTRING_INIT; sge_dstring_sprintf(&thread_name, "%s%03d", threadnames[WORKER_THREAD], i); cl_thread_list_create_thread(Main_Control.worker_thread_pool, &dummy_thread_p, cl_com_get_log_list(), sge_dstring_get_string(&thread_name), i, sge_worker_main, NULL, NULL, CL_TT_WORKER); sge_dstring_free(&thread_name); } DRETURN_VOID; }
/****** report_exit_status() *************************************************** * NAME * report_exit_status() -- Prints a job's exit status * * SYNOPSIS * static int report_exit_status(int stat, const char *jobid) * * FUNCTION * Prints a job's exit status to stdout. * * INPUT * int stat - The job's exit status * const char *jobid - The job id string * * RESULT * static int - The exit code of the job * * NOTES * MT-NOTES: report_exit_status() is MT safe *******************************************************************************/ static int report_exit_status(int stat, const char *jobid) { int aborted, exited, signaled; int exit_status = 0; japi_wifaborted(&aborted, stat, NULL); if (aborted) { printf(MSG_QSUB_JOBNEVERRAN_S, jobid); } else { japi_wifexited(&exited, stat, NULL); if (exited) { japi_wexitstatus(&exit_status, stat, NULL); printf(MSG_QSUB_JOBEXITED_SI, jobid, exit_status); } else { japi_wifsignaled(&signaled, stat, NULL); if (signaled) { dstring termsig = DSTRING_INIT; japi_wtermsig(&termsig, stat, NULL); printf(MSG_QSUB_JOBRECEIVEDSIGNAL_SS, jobid, sge_dstring_get_string(&termsig)); sge_dstring_free(&termsig); } else { printf(MSG_QSUB_JOBFINISHUNCLEAR_S, jobid); } exit_status = 1; } } printf("\n"); return exit_status; }
/****** qsub_terminate() ******************************************************* * NAME * qsub_terminate() -- Terminates qsub * * SYNOPSIS * void qsub_terminate(void) * * FUNCTION * Prints out messages that qsub is ending and exits JAPI. * * NOTES * MT-NOTES: qsub_terminate() is MT safe *******************************************************************************/ static void qsub_terminate(void) { dstring diag = DSTRING_INIT; int tmp_ret; fprintf(stderr, "\n%s\n", MSG_QSUB_INTERRUPTED); fprintf(stderr, "%s\n", MSG_QSUB_TERMINATING); tmp_ret = japi_exit(JAPI_EXIT_KILL_PENDING, &diag); /* No active session here means that the main thread beat us to exiting, in which case, we just quietly give up and go away. */ if ((tmp_ret != DRMAA_ERRNO_SUCCESS) && (tmp_ret != DRMAA_ERRNO_NO_ACTIVE_SESSION)) { fprintf(stderr, "\n"); fprintf(stderr, MSG_QSUB_COULDNOTFINALIZEENV_S, sge_dstring_get_string(&diag)); fprintf(stderr, "\n"); } sge_dstring_free(&diag); sge_mutex_lock("qsub_exit_mutex", "qsub_terminate", __LINE__, &exit_mutex); exited = true; pthread_cond_signal(&exit_cv); sge_mutex_unlock("qsub_exit_mutex", "qsub_terminate", __LINE__, &exit_mutex); }
/****** shepherd_binding/create_binding_env_linux() **************************** * NAME * create_binding_env_linux() -- Creates SGE_BINDING env variable. * * SYNOPSIS * bool create_binding_env_linux(const int* proc_id, const int amount) * * FUNCTION * Creates the SGE_BINDING environment variable on Linux operating system. * This environment variable contains a space separated list of Linux * internal processor ids given as input parameter. * * INPUTS * const int* proc_id - List of processor ids. * const int amount - Length of processor id list. * * RESULT * bool - true when SGE_BINDING env var could be generated false if not * * NOTES * MT-NOTE: create_binding_env_linux() is MT safe * *******************************************************************************/ bool create_binding_env_linux(const int* proc_id, const int amount) { bool retval = true; dstring sge_binding = DSTRING_INIT; dstring proc = DSTRING_INIT; int i; for (i = 0; i < amount; i++) { sge_dstring_clear(&proc); /* DG TODO env ends with whitespace char */ sge_dstring_sprintf(&proc, "%d ", proc_id[i]); sge_dstring_append_dstring(&sge_binding, &proc); } if (sge_setenv("SGE_BINDING", sge_dstring_get_string(&sge_binding)) != 1) { /* settting env var was not successful */ retval = false; shepherd_trace("create_binding_env_linux: Couldn't set environment variable!"); } sge_dstring_free(&sge_binding); sge_dstring_free(&proc); return retval; }
void xml_addAttribute(lListElem *xml_elem, const char *name, const char *value) { lListElem *attr_elem = lCreateElem(XMLA_Type); lList *attr_list = NULL; dstring mod_value = DSTRING_INIT; bool is_mod_value; DENTER(CULL_LAYER, "xml_addAttribute"); is_mod_value = escape_string(value, &mod_value); if (attr_elem) { lSetString(attr_elem, XMLA_Name, name); lSetString(attr_elem, XMLA_Value, (is_mod_value?sge_dstring_get_string(&mod_value):"")); if (lGetPosViaElem(xml_elem, XMLH_Attribute, SGE_NO_ABORT) != -1) { attr_list = lGetList(xml_elem, XMLH_Attribute); if (!attr_list) lSetList(xml_elem, XMLH_Attribute, (attr_list = lCreateList("Attributes", XMLA_Type))); } else if (lGetPosViaElem(xml_elem, XMLE_Attribute, SGE_NO_ABORT) != -1) { attr_list = lGetList(xml_elem, XMLE_Attribute); if (!attr_list) lSetList(xml_elem, XMLE_Attribute, (attr_list = lCreateList("Attributes", XMLA_Type))); } else { sge_dstring_free(&mod_value); CRITICAL((SGE_EVENT, "xml_addAttribute() called on wrong cull structure")); DEXIT; abort(); } lAppendElem(attr_list, attr_elem); } sge_dstring_free(&mod_value); DEXIT; return; }
/****** sge_client_ijs/force_ijs_server_shutdown() ***************************** * NAME * force_ijs_server_shutdown() -- forces the commlib server for the builtin * interactive job support to shut down * * SYNOPSIS * int force_ijs_server_shutdown(COMM_HANDLE **phandle, const char * *this_component, dstring *p_err_msg) * * FUNCTION * Forces the commlib server for the builtin interactive job support to shut * down immediately and ensures it is shut down. * * INPUTS * COMM_HANDLE **phandle - Handle of the COMM connection, gets set to * NULL in this function. * const char *this_component - Name of this component. * dstring *p_err_msg - Contains the error reason in case of error. * * RESULT * int - 0: OK * 1: Invalid parameter: phandle == NULL or *phandle == NULL * 2: Can't shut down connection, see p_err_msg for details * * NOTES * MT-NOTE: force_ijs_server_shutdown() is not MT safe * * SEE ALSO * sge_client_ijs/start_ijs_server() * sge_client_ijs/run_ijs_server() * sge_client_ijs/stop_ijs_server_shutdown() *******************************************************************************/ int force_ijs_server_shutdown(COMM_HANDLE **phandle, const char *this_component, dstring *p_err_msg) { int ret; DENTER(TOP_LAYER, "force_ijs_server_shutdown"); if (phandle == NULL || *phandle == NULL) { sge_dstring_sprintf(p_err_msg, "invalid connection handle"); DPRINTF(("invalid connection handle - nothing to shut down\n")); DRETURN(1); } DPRINTF(("connection is still alive\n")); /* This will remove the handle */ ret = comm_shutdown_connection(*phandle, COMM_CLIENT, g_hostname, p_err_msg); sge_free(&g_hostname); if (ret != COMM_RETVAL_OK) { DPRINTF(("comm_shutdown_connection() failed: %s (%d)\n", sge_dstring_get_string(p_err_msg), ret)); ret = 2; } else { DPRINTF(("successfully shut down the connection\n")); } *phandle = NULL; DRETURN(ret); }
/****** uti/dstring/sge_dstring_strip_white_space_at_eol() ********************* * NAME * sge_dstring_strip_white_space_at_eol() -- as it says * * SYNOPSIS * void sge_dstring_strip_white_space_at_eol(dstring *string) * * FUNCTION * removes whitespace at the end of the given "string". * * INPUTS * dstring *string - dstring *******************************************************************************/ void sge_dstring_strip_white_space_at_eol(dstring *string) { DENTER(DSTRING_LAYER, "sge_strip_white_space_at_eol"); if (string != NULL) { char *s = (string != NULL) ? string->s : NULL; if (s != NULL) { sge_strip_white_space_at_eol(s); } } DRETURN_VOID; } #if 0 /* EB: DEBUG: */ int main(void) { char *s; dstring sb = DSTRING_INIT; /* initialize */ /* * change content */ s = sge_dstring_append(&sb, "Trala"); s = sge_dstring_append(&sb, " trolo"); s = sge_dstring_append(&sb, " troet"); s = sge_dstring_sprintf(&sb, "%d, %s, %f\n", 5, "rabarber ", 5.6); /* * use string */ printf("%s\n", s); printf("%s\n", sge_dstring_get_string(&sb)); /* * free the string when no longer needed */ sge_dstring_free(&sb); return 0; }
static int enumeration_compare(const lEnumeration *what1, const lEnumeration *what2) { int ret; dstring str1 = DSTRING_INIT; dstring str2 = DSTRING_INIT; lWriteWhatToDString(what1, &str1); lWriteWhatToDString(what2, &str2); ret = strcmp(sge_dstring_get_string(&str1), sge_dstring_get_string(&str2)); sge_dstring_free(&str1); sge_dstring_free(&str2); return ret; }
static int spawn_file(dstring *aBuffer, dstring *error_message) { int my_errno; char* mktemp_return = NULL; char tmp_file_string[256]; char tmp_string[SGE_PATH_MAX]; /* * generate template filename for mktemp() */ snprintf(tmp_file_string, 256, "pid-%u-XXXXXX", (unsigned int)getpid()); /* * check final length of path */ if (sge_dstring_strlen(aBuffer) + strlen(tmp_file_string) >= SGE_PATH_MAX) { sge_dstring_append(aBuffer, tmp_file_string); sge_dstring_sprintf(error_message, MSG_TMPNAM_SGE_MAX_PATH_LENGTH_US, sge_u32c(SGE_PATH_MAX), sge_dstring_get_string(aBuffer)); return -1; } /* * now build full path string for mktemp() */ snprintf(tmp_string, SGE_PATH_MAX, "%s%s", sge_dstring_get_string(aBuffer), tmp_file_string); /* * generate temp file by call to mktemp() */ errno = 0; mktemp_return = mktemp(tmp_string); my_errno = errno; if (mktemp_return[0] == '\0') { sge_dstring_sprintf(error_message, MSG_TMPNAM_GOT_SYSTEM_ERROR_SS, strerror(my_errno), sge_dstring_get_string(aBuffer)); return -1; } /* * finally copy the resulting path to aBuffer */ sge_dstring_sprintf(aBuffer, tmp_string); return 0; }
void test_linux_plpa() { dstring error = DSTRING_INIT; char* topology = NULL; int length = 0; int s, c; struct utsname name; if (uname(&name) != -1) { printf("Your Linux kernel version is: %s\n", name.release); } if (!_has_core_binding(&error)) { printf("Your Linux kernel seems not to offer core binding capabilities for PLPA!\nReason: %s\n", sge_dstring_get_string(&error)); } if (!_has_topology_information()) { printf("No topology information could by retrieved by PLPA!\n"); } else { /* get amount of sockets */ printf("Amount of sockets:\t\t%d\n", get_amount_of_sockets()); /* get amount of cores */ printf("Amount of cores:\t\t%d\n", get_total_amount_of_cores()); /* get topology */ get_topology_linux(&topology, &length); printf("Topology:\t\t\t%s\n", topology); sge_free(&topology); printf("Mapping of logical socket and core numbers to internal\n"); /* for each socket,core pair get the internal processor number */ /* try multi-mapping */ for (s = 0; s < get_amount_of_sockets(); s++) { for (c = 0; c < get_amount_of_cores(s); c++) { int* proc_ids = NULL; int amount = 0; if (get_processor_ids_linux(s, c, &proc_ids, &amount)) { int i = 0; printf("Internal processor ids for socket %5d core %5d: ", s , c); for (i = 0; i < amount; i++) { printf(" %5d", proc_ids[i]); } printf("\n"); sge_free(&proc_ids); } else { printf("Couldn't get processor ids for socket %5d core %5d\n", s, c); } } } } sge_dstring_free(&error); return; }
/****** sge/opt/opt_list_append_opts_from_default_files() ********************* * NAME * opt_list_append_opts_from_default_files() -- parse default files * * SYNOPSIS * void opt_list_append_opts_from_default_files( * lList **pcmdline, * lList **answer_list * char **envp) * * FUNCTION * This function reads the 3 defaults files if they exist and parses them * into an options list. * * INPUTS * lList **pcmdline - pointer to SPA_Type list, if list is NULL, it is * created if the files contain any options * lList* - answer list, AN_Type or NULL if everything ok * possible errors: * STATUS_ENOSUCHUSER - could not retrieve passwd info on me.user_name * STATUS_EDISK - home directory for user is missing or cwd * cannot be read or file could not be opened * (is just a warning) * STATUS_EEXIST - (parse_script_file), (is just a warning) * STATUS_EUNKNOWN - (parse_script_file), error opening or * reading from existing file, (is just a warning) * plus all other error stati returned by * parse_script_file, see there * char **envp - environment pointer * * NOTES * MT-NOTE: opt_list_append_opts_from_default_files() is MT safe *******************************************************************************/ void opt_list_append_opts_from_default_files(u_long32 prog_number, const char* cell_root, const char* user, lList **pcmdline, lList **answer_list, char **envp) { dstring req_file = DSTRING_INIT; char *def_files[3 + 1]; DENTER(TOP_LAYER, "opt_list_append_opts_from_default_files"); lFreeList(answer_list); /* the sge root defaults file */ get_root_file_path(&req_file, cell_root, SGE_COMMON_DEF_REQ_FILE); def_files[0] = strdup(sge_dstring_get_string(&req_file)); /* * the defaults file in the user's home directory */ get_user_home_file_path(&req_file, SGE_HOME_DEF_REQ_FILE, user, answer_list); def_files[1] = strdup(sge_dstring_get_string(&req_file)); /* * the defaults file in the current working directory */ def_files[2] = get_cwd_defaults_file_path(answer_list); def_files[3] = NULL; /* * now read all the defaults files, unaware of where they came from */ append_opts_from_default_files(prog_number, pcmdline, answer_list, envp, def_files); /* MT-NOTE !!!! */ sge_dstring_free(&req_file); DRETURN_VOID; }
/****** uti/stdlib/sge_setenv() *********************************************** * NAME * sge_setenv() -- Change or add an environment variable * * SYNOPSIS * int sge_setenv(const char *name, const char *value) * * FUNCTION * Change or add an environment variable * * INPUTS * const char *name - variable name * const char *value - new value * * RESULT * int - error state * 1 - success * 0 - error * * SEE ALSO * uti/stdlib/sge_putenv() * uti/stdlib/sge_getenv() * uti/stdio/addenv() * * NOTES * MT-NOTE: sge_setenv() is MT safe *******************************************************************************/ int sge_setenv(const char *name, const char *value) { int ret = 0; if (name != NULL && value != NULL) { dstring variable = DSTRING_INIT; sge_dstring_sprintf(&variable, "%s=%s", name, value); ret = sge_putenv(sge_dstring_get_string(&variable)); sge_dstring_free(&variable); } return ret; }
/****** shepherd/shepconf/shepconf_has_notify_signal() ************************ * NAME * shepconf_has_notify_signal() -- Do we have a notification signal * * SYNOPSIS * int shepconf_has_notify_signal(char *notify_name, int *signal) * * FUNCTION * This function checks if the notification mechanism is enabled. * In this case the function will retuen 'true' and it will * return the default signal or the user defined signal for * the given "notify_name". * * INPUTS * char *notify_name - "notify_susp" or "notify_kill" * int *signal - signal id * * RESULT * int - true or false *******************************************************************************/ int shepconf_has_notify_signal(const char *notify_name, int *signal) { const char *notify_array[] = { "notify_susp", "notify_kill", NULL }; int signal_array[] = { SIGUSR1, SIGUSR2, 0 }; dstring param_name = DSTRING_INIT; char *conf_type = NULL; int conf_id; int ret = 0; /* * There are three possibilities: * a) There is a user defined signal which should be used * b) Default signal should be used * c) Notification mechanism is disabled */ sge_dstring_sprintf(¶m_name, "%s%s", notify_name, "_type"); conf_type = search_conf_val(sge_dstring_get_string(¶m_name)); sge_dstring_free(¶m_name); if (conf_type != NULL) { conf_id = atol(conf_type); } else { conf_id = 1; /* Default signal should be used */ } if (conf_id == 0) { char *conf_signal = search_conf_val(notify_name); if (conf_signal != NULL) { *signal = sge_sys_str2signal(conf_signal); ret = 1; } } else if (conf_id == 1) { int i; for (i = 0; notify_array[i] != NULL; i++) { if (!strcmp(notify_array[i], notify_name)) { break; } } *signal = signal_array[i]; ret = 1; } else { *signal = 0; ret = 0; } return ret; }
/*-------------------------------------------------------------------------*/ static void qmonCalendarFillConf( Widget w, lListElem *ep ) { XmString *items; Cardinal itemCount; const char *s; int i; dstring sb = DSTRING_INIT; DENTER(GUI_LAYER, "qmonCalendarFillConf"); if (!ep) { /* ** clear the cal_conf_list */ XtVaSetValues( cal_conf_list, XmNitems, NULL, XmNitemCount, 0, NULL); DEXIT; return; } itemCount = 2; items = (XmString*) XtMalloc(sizeof(XmString)*itemCount); i = 0; /* year calendar */ sge_dstring_sprintf(&sb, "%-20.20s ", XmtLocalize(w, "Year", "Year")); sge_dstring_append(&sb, (s=lGetString(ep, CAL_year_calendar))?s: XmtLocalize(w, "NONE", "NONE")); items[i++] = XmStringCreateLtoR(sb.s, "LIST"); sge_dstring_free(&sb); /* week calendar */ sge_dstring_sprintf(&sb, "%-20.20s ", XmtLocalize(w, "Week", "Week")); sge_dstring_append(&sb, (s=lGetString(ep, CAL_week_calendar))?s: XmtLocalize(w, "NONE", "NONE")); items[i++] = XmStringCreateLtoR((char*)sge_dstring_get_string(&sb), "LIST"); sge_dstring_free(&sb); XtVaSetValues( cal_conf_list, XmNitems, items, XmNitemCount, itemCount, NULL); XmStringTableFree(items, itemCount); DEXIT; }
/****** uti/monitor/sge_monitor_output() *************************************** * NAME * sge_monitor_output() -- outputs the result into the message file * * SYNOPSIS * void sge_monitor_output(monitoring_t *monitor) * * FUNCTION * This function computes the output line from the gathered statistics. * The output is only generated, when the the output flag in the * monitoring structure is set. * * The monitoring line is printed to the message file in the profiling * class and it made available for the qping -f output. For the qping * output, it stores the the generation time, though that qping can * show, when the message was generated. * * If an extension is set, it calls the apropriate output function for * it. * * INPUTS * monitoring_t *monitor - the monitoring info * * NOTES * MT-NOTE: sge_monitor_output() is MT safe * *******************************************************************************/ void sge_monitor_output(monitoring_t *monitor) { DENTER(GDI_LAYER, "sge_monitor_output"); if ((monitor != NULL) && (monitor->output == true)) { struct timeval after; double time; gettimeofday(&after, NULL); time = after.tv_usec - monitor->now.tv_usec; time = after.tv_sec - monitor->now.tv_sec + (time/1000000); sge_dstring_clear(monitor->work_line); sge_dstring_sprintf_append(monitor->work_line, MSG_UTI_MONITOR_DEFLINE_SF, monitor->thread_name, monitor->message_in_count/time); if (monitor->ext_type != NONE_EXT) { sge_dstring_append(monitor->work_line, " ("); monitor->ext_output(monitor->work_line, monitor->ext_data, time); sge_dstring_append(monitor->work_line, ")"); }; sge_dstring_sprintf_append(monitor->work_line, MSG_UTI_MONITOR_DEFLINE_FFFFF, monitor->message_out_count/time, monitor->message_in_count ? (time - monitor->idle)/monitor->message_in_count: 0, monitor->idle/time*100, monitor->wait/time*100, time); /* only log into the message file, if the user wants it */ if (monitor->log_monitor_mes) { sge_log(LOG_PROF, sge_dstring_get_string(monitor->work_line),__FILE__,SGE_FUNC,__LINE__); } if (monitor->pos != -1) { dstring *tmp = NULL; sge_mutex_lock("sge_monitor_init", SGE_FUNC, __LINE__, &(Output[monitor->pos].Output_Mutex)); tmp = Output[monitor->pos].output; Output[monitor->pos].output = monitor->work_line; Output[monitor->pos].update_time = after.tv_sec; sge_mutex_unlock("sge_monitor_init", SGE_FUNC, __LINE__, &(Output[monitor->pos].Output_Mutex)); monitor->work_line = tmp; } sge_monitor_reset(monitor); } DRETURN_VOID; }
/****** uti/dstring/sge_dstring_copy_dstring() ******************************** * NAME * sge_dstring_copy_dstring() -- strcpy() for dstrings's * * SYNOPSIS * const char* sge_dstring_copy_dstring(dstring *sb1, * const dstring *sb2) * * FUNCTION * strcpy() for dstrings's * * INPUTS * dstring *sb1 - destination dstring * const dstring *sb2 - source dstring * * NOTES * MT-NOTE: sge_dstring_copy_dstring() is MT safe * * RESULT * const char* - result string buffer *******************************************************************************/ const char *sge_dstring_copy_dstring(dstring *sb1, const dstring *sb2) { const char *ret = NULL; DENTER(DSTRING_LAYER, "sge_dstring_copy_dstring"); if (sb1 != NULL) { sge_dstring_clear(sb1); ret = sge_dstring_append(sb1, sge_dstring_get_string(sb2)); } DEXIT; return ret; }
/****** uti/sge_tmpnam/sge_tmpnam() ******************************************* * NAME * sge_tmpnam() -- Secure replacement for tmpnam() * * SYNOPSIS * char* sge_tmpnam(char *aBuffer) * * FUNCTION * Generate a string that is a unique valid filename within a given * directory. The corresponding file is created as soon as the filename * has been generated, thus avoiding any delay between filename generation * and actual file usage. The file will have read and write access for the * user only. * * The 'aBuffer' argument points to an array of at least SGE_PATH_MAX length. * 'aBuffer' will contain the generated filename upon successful completion. * In addition, 'aBuffer' will be returned. If the function fails, NULL will * be returned and 'errno' set to indicate the error. * * If the environment variable TMPDIR is defined, it's value will be used * as the path prefix for the file. If TMPDIR is not set or it does not * refer to a valid directory, the value of P_tmpdir will be used. * P_tmpdir shall be defined in <stdio.h>. If P_tmpdir is not defined or * it does not refer to a valid directory, /tmp will be used. * * NOTE: Since the file already exists, the O_EXCL flag must not be used if * the returned filename is opened for usage within an application. It is, * however, the duty of the application calling this function to delete the * file denoted by the generated filename after it is no longer needed. * * INPUTS * char *aBuffer - Array to hold filename * * RESULT * char* - Points to 'aBuffer' if successful, NULL otherwise * * NOTE * MT-NOTE: sge_tmpnam() is MT safe. ******************************************************************************/ char *sge_tmpnam(char *aBuffer, dstring *error_message) { dstring s = DSTRING_INIT; DENTER(TOP_LAYER, "sge_tmpnam"); if (aBuffer == NULL) { sge_dstring_sprintf(error_message, MSG_TMPNAM_GOT_NULL_PARAMETER); DEXIT; return NULL; } if (elect_path(&s) < 0) { sge_dstring_sprintf(error_message, MSG_TMPNAM_CANNOT_GET_TMP_PATH); sge_dstring_free(&s); DEXIT; return NULL; } if ((sge_dstring_get_string(&s))[sge_dstring_strlen(&s)-1] != '/') { sge_dstring_append_char(&s, '/'); } if (spawn_file(&s, error_message) < 0) { sge_dstring_free(&s); DEXIT; return NULL; } sge_strlcpy(aBuffer, sge_dstring_get_string(&s), SGE_PATH_MAX); sge_dstring_free(&s); DPRINTF(("sge_tmpnam: returning %s\n", aBuffer)); DEXIT; return aBuffer; }
void sge_signaler_initialize(sge_gdi_ctx_class_t *ctx) { cl_thread_settings_t* dummy_thread_p = NULL; dstring thread_name = DSTRING_INIT; DENTER(TOP_LAYER, "sge_signaler_initialize"); sge_dstring_sprintf(&thread_name, "%s%03d", threadnames[SIGNALER_THREAD], 0); cl_thread_list_setup(&(Main_Control.signal_thread_pool), "signal thread pool"); cl_thread_list_create_thread(Main_Control.signal_thread_pool, &dummy_thread_p, cl_com_get_log_list(), sge_dstring_get_string(&thread_name), 0, sge_signaler_main, NULL, NULL, CL_TT_SIGNALER); sge_dstring_free(&thread_name); DRETURN_VOID; }
void sge_event_master_initialize(sge_gdi_ctx_class_t *ctx) { cl_thread_settings_t* dummy_thread_p = NULL; dstring thread_name = DSTRING_INIT; DENTER(TOP_LAYER, "sge_event_master_initialize"); DPRINTF(("event master functionality has been initialized\n")); sge_dstring_sprintf(&thread_name, "%s%03d", threadnames[DELIVERER_THREAD], 0); cl_thread_list_setup(&(Main_Control.event_master_thread_pool), "event master thread pool"); cl_thread_list_create_thread(Main_Control.event_master_thread_pool, &dummy_thread_p, cl_com_get_log_list(), sge_dstring_get_string(&thread_name), 0, sge_event_master_main, NULL, NULL, CL_TT_DELIVERER); sge_dstring_free(&thread_name); DRETURN_VOID; }
/****** uti/dstring/sge_dstring_ulong_to_binstring() ************************** * NAME * sge_dstring_ulong_to_binstring() -- convert ulong into bin-string * * SYNOPSIS * const char* * sge_dstring_ulong_to_binstring(dstring *sb, u_long32 number) * * FUNCTION * Convert ulong into bin-strin * * INPUTS * dstring *sb - dstring * u_long32 number - 32 bit ulong value * * RESULT * const char* - pointer to dstrings internal buffer *******************************************************************************/ const char *sge_dstring_ulong_to_binstring(dstring *sb, u_long32 number) { char buffer[33] = " "; int i = 31; while (number > 0) { if ((number % 2) > 0) { buffer[i] = '1'; } else { buffer[i] = '0'; } i--; number /= 2; } sge_strip_blanks(buffer); sge_dstring_sprintf(sb, buffer); return sge_dstring_get_string(sb); }
void showError(sge_error_class_t *eh) { sge_error_iterator_class_t *iter = NULL; dstring ds = DSTRING_INIT; bool first = true; iter = eh->iterator(eh); while (iter && iter->next(iter)) { if (first) { first = true; } else { sge_dstring_append(&ds, "\n"); } sge_dstring_append(&ds, iter->get_message(iter)); } printf("%s\n", sge_dstring_get_string(&ds)); sge_dstring_free(&ds); }
/****** uti/dstring/sge_dstring_split() **************************************** * NAME * sge_dstring_split() -- splits a string into two parts * * SYNOPSIS * bool * sge_dstring_split(dstring *string, char character, * dstring *before, dstring *after) * * FUNCTION * This functions tires to find the first occurence of "character" * in "string". The characters before will be copied into "before" * and the characters behind into "after" dstring. * * INPUTS * dstring *sb - dstring * char character - character * dstring *before - characters before * dstring *after - characters after * * RESULT * error state * true - success * false - error *******************************************************************************/ bool sge_dstring_split(dstring *string, char character, dstring *before, dstring *after) { bool ret = true; DENTER(DSTRING_LAYER, "sge_dstring_split"); if (string != NULL && before != NULL && after != NULL) { const char *s = sge_dstring_get_string(string); const char *end = strchr(s, character); while (end != NULL && s != end) { sge_dstring_append_char(before, *(s++)); } if (*s == character) { s++; } sge_dstring_append(after, s); } DRETURN(ret); }
/****** uti/spool/sge_get_active_job_file_path() ******************************** * NAME * sge_get_active_job_file_path() -- Create paths in active_jobs dir * * SYNOPSIS * const char* sge_get_active_job_file_path(dstring *buffer, * u_long32 job_id, u_long32 ja_task_id, const char *pe_task_id, * const char *filename) * * FUNCTION * Creates paths in the execd's active_jobs directory. * Both directory and file paths can be created. * The result is placed in a buffer provided by the caller. * * WARNING: Do only use in shepherd and execution daemon! * * INPUTS * dstring *buffer - buffer to hold the generated path * u_long32 job_id - job id * u_long32 ja_task_id - array task id * const char *pe_task_id - optional pe task id * const char *filename - optional file name * * RESULT * const char* - pointer to the string buffer on success, else NULL * * EXAMPLE * To create the relative path to a jobs/tasks environment file, the * following call would be used: * * char buffer[SGE_PATH_MAX] * sge_get_active_job_file_path(buffer, SGE_PATH_MAX, * job_id, ja_task_id, pe_task_id, * "environment"); * * * NOTES * JG: TODO: The function might be converted to or might use a more * general path creating function (utilib). * * SEE ALSO * execd/sge_make_ja_task_active_dir() * execd/sge_make_pe_task_active_dir() *******************************************************************************/ const char *sge_get_active_job_file_path(dstring *buffer, u_long32 job_id, u_long32 ja_task_id, const char *pe_task_id, const char *filename) { DENTER(TOP_LAYER, "sge_get_active_job_file_path"); if (buffer == NULL) { DRETURN(NULL); } sge_dstring_sprintf(buffer, "%s/"sge_u32"."sge_u32, ACTIVE_DIR, job_id, ja_task_id); if (pe_task_id != NULL) { sge_dstring_append_char(buffer, '/'); sge_dstring_append(buffer, pe_task_id); } if (filename != NULL) { sge_dstring_append_char(buffer, '/'); sge_dstring_append(buffer, filename); } DRETURN(sge_dstring_get_string(buffer)); }
/****** category/sge_build_job_cs_category() *********************************** * NAME * sge_build_job_cs_category() -- generates the category string for the sc * * SYNOPSIS * const char* sge_build_job_cs_category(dstring *category_str, lListElem * *job, lListElem *cat_obj) * * FUNCTION * ??? * * INPUTS * dstring *category_str - storage forthe c string * lListElem *job - job for which to create a category * lListElem *cat_obj - regular category for the job. * * RESULT * const char* - * * EXAMPLE * ??? * * NOTES * MT-NOTE: sge_build_job_cs_category() is MT safe * *******************************************************************************/ const char* sge_build_job_cs_category(dstring *category_str, lListElem *job, lListElem *cat_obj, bool did_project) { const char *p; DENTER(TOP_LAYER, "sge_build_job_cs_category"); /* * deadline */ sge_dstring_sprintf_append(category_str, "-dl "sge_u32, lGetUlong(job, JB_deadline)); /* * priority */ sge_dstring_sprintf_append(category_str, "-p "sge_u32, lGetUlong(job, JB_priority)); sge_dstring_sprintf_append(category_str, "-ot "sge_u32, lGetUlong(job, JB_override_tickets)); sge_dstring_sprintf_append(category_str, "-js "sge_u32, lGetUlong(job, JB_jobshare)); sge_dstring_sprintf_append(category_str, "-u %s", lGetString(job, JB_owner)); /* * ticket assignment can depend on a jobs project. * If the project was not added to the resource categories * it gets added directly to the cs category string */ if ((p=lGetString(job, JB_project)) && !did_project) sge_dstring_sprintf_append(category_str, " -P %s", p); /* * id for the resource category * I use teh address of the resource category as a hash value for its string. */ sge_dstring_sprintf_append(category_str, " %x", cat_obj); DEXIT; return sge_dstring_get_string(category_str); }
int main(int argc, char *argv[]) { qevent_options enabled_options; dstring errors = DSTRING_INIT; int i, gdi_setup; lList *alp = NULL; sge_gdi_ctx_class_t *ctx = NULL; sge_evc_class_t *evc = NULL; DENTER_MAIN(TOP_LAYER, "qevent"); /* sge_mt_init(); */ /* dump pid to file */ qevent_dump_pid_file(); /* parse command line */ enabled_options.error_message = &errors; qevent_set_option_struct(&enabled_options); qevent_parse_command_line(argc, argv, &enabled_options); /* check if help option is set */ if (enabled_options.help_option) { qevent_show_usage(); sge_dstring_free(enabled_options.error_message); SGE_EXIT((void**)&ctx, 0); } /* are there command line parsing errors ? */ if (sge_dstring_get_string(enabled_options.error_message)) { ERROR((SGE_EVENT, "%s", sge_dstring_get_string(enabled_options.error_message) )); qevent_show_usage(); sge_dstring_free(enabled_options.error_message); SGE_EXIT((void**)&ctx, 1); } log_state_set_log_gui(1); sge_setup_sig_handlers(QEVENT); /* setup event client */ gdi_setup = sge_gdi2_setup(&ctx, QEVENT, MAIN_THREAD, &alp); if (gdi_setup != AE_OK) { answer_list_output(&alp); sge_dstring_free(enabled_options.error_message); SGE_EXIT((void**)&ctx, 1); } /* TODO: how is the memory we allocate here released ???, SGE_EXIT doesn't */ if (false == sge_gdi2_evc_setup(&evc, ctx, EV_ID_ANY, &alp, NULL)) { answer_list_output(&alp); sge_dstring_free(enabled_options.error_message); SGE_EXIT((void**)&ctx, 1); } /* ok, start over ... */ /* check for testsuite option */ if (enabled_options.testsuite_option) { /* only for testsuite */ qevent_testsuite_mode(evc); sge_dstring_free(enabled_options.error_message); SGE_EXIT((void**)&ctx, 0); } /* check for subscribe option */ if (enabled_options.subscribe_option) { /* only for testsuite */ qevent_subscribe_mode(evc); sge_dstring_free(enabled_options.error_message); SGE_EXIT((void**)&ctx, 0); } if (enabled_options.trigger_option_count > 0) { lCondition *where =NULL; lEnumeration *what = NULL; sge_mirror_initialize(evc, EV_ID_ANY, "sge_mirror -trigger", true, NULL, NULL, NULL, NULL, NULL); evc->ec_set_busy_handling(evc, EV_BUSY_UNTIL_ACK); /* put out information about -trigger option */ for (i=0;i<enabled_options.trigger_option_count;i++) { INFO((SGE_EVENT, "trigger script for %s events: %s\n", qevent_get_event_name((enabled_options.trigger_option_events)[i]), (enabled_options.trigger_option_scripts)[i])); switch((enabled_options.trigger_option_events)[i]) { case QEVENT_JB_END: /* build mask for the job structure to contain only the needed elements */ where = NULL; what = lWhat("%T(%I %I %I %I %I %I %I %I)", JB_Type, JB_job_number, JB_ja_tasks, JB_ja_structure, JB_ja_n_h_ids, JB_ja_u_h_ids, JB_ja_s_h_ids,JB_ja_o_h_ids, JB_ja_template); /* register for job events */ sge_mirror_subscribe(evc, SGE_TYPE_JOB, analyze_jatask_event, NULL, NULL, where, what); evc->ec_set_flush(evc, sgeE_JOB_DEL,true, 1); /* the mirror interface registers more events, than we need, thus we free the ones, we do not need */ /* evc->ec_unsubscribe(evc, sgeE_JOB_LIST); */ evc->ec_unsubscribe(evc, sgeE_JOB_MOD); evc->ec_unsubscribe(evc, sgeE_JOB_MOD_SCHED_PRIORITY); evc->ec_unsubscribe(evc, sgeE_JOB_USAGE); evc->ec_unsubscribe(evc, sgeE_JOB_FINAL_USAGE); /* evc->ec_unsubscribe(evc, sgeE_JOB_ADD); */ /* free the what and where mask */ lFreeWhere(&where); lFreeWhat(&what); break; case QEVENT_JB_TASK_END: /* build mask for the job structure to contain only the needed elements */ where = NULL; what = lWhat("%T(%I)", JAT_Type, JAT_status); /* register for JAT events */ sge_mirror_subscribe(evc, SGE_TYPE_JATASK, analyze_jatask_event, NULL, NULL, where, what); evc->ec_set_flush(evc, sgeE_JATASK_DEL,true, 1); /* the mirror interface registers more events, than we need, thus we free the ones, we do not need */ evc->ec_unsubscribe(evc, sgeE_JATASK_ADD); evc->ec_unsubscribe(evc, sgeE_JATASK_MOD); /* free the what and where mask */ lFreeWhere(&where); lFreeWhat(&what); break; } } while(!shut_me_down) { sge_mirror_error error = sge_mirror_process_events(evc); if (error == SGE_EM_TIMEOUT && !shut_me_down ) { sleep(10); continue; } } sge_mirror_shutdown(evc); sge_dstring_free(enabled_options.error_message); sge_prof_cleanup(); SGE_EXIT((void**)&ctx, 0); return 0; } ERROR((SGE_EVENT, "no option selected\n" )); qevent_show_usage(); sge_dstring_free(enabled_options.error_message); sge_prof_cleanup(); SGE_EXIT((void**)&ctx, 1); return 1; }
int main(int argc, char **argv) { lList *pcmdline = NULL; lList *alp = NULL; sge_gdi_ctx_class_t *ctx = NULL; lList *ar_lp = NULL; lListElem *ar = NULL; DENTER_MAIN(TOP_LAYER, "qrsub"); /* Set up the program information name */ sge_setup_sig_handlers(QRSUB); log_state_set_log_gui(1); if (sge_gdi2_setup(&ctx, QRSUB, MAIN_THREAD, &alp) != AE_OK) { answer_list_output(&alp); goto error_exit; } /* ** stage 1 of commandline parsing */ { dstring file = DSTRING_INIT; const char *user = ctx->get_username(ctx); const char *cell_root = ctx->get_cell_root(ctx); /* arguments from SGE_ROOT/common/sge_ar_request file */ get_root_file_path(&file, cell_root, SGE_COMMON_DEF_AR_REQ_FILE); if ((alp = parse_script_file(QRSUB, sge_dstring_get_string(&file), "", &pcmdline, environ, FLG_HIGHER_PRIOR | FLG_IGN_NO_FILE)) == NULL) { /* arguments from $HOME/.sge_ar_request file */ if (get_user_home_file_path(&file, SGE_HOME_DEF_AR_REQ_FILE, user, &alp)) { lFreeList(&alp); alp = parse_script_file(QRSUB, sge_dstring_get_string(&file), "", &pcmdline, environ, FLG_HIGHER_PRIOR | FLG_IGN_NO_FILE); } } sge_dstring_free(&file); if (alp) { answer_list_output(&alp); lFreeList(&pcmdline); goto error_exit; } } alp = cull_parse_cmdline(QRSUB, argv+1, environ, &pcmdline, FLG_USE_PSEUDOS); if (answer_list_print_err_warn(&alp, NULL, "qrsub: ", MSG_WARNING) > 0) { lFreeList(&pcmdline); goto error_exit; } if (!pcmdline) { /* no command line option is present: print help to stderr */ sge_usage(QRSUB, stderr); fprintf(stderr, "%s\n", MSG_PARSE_NOOPTIONARGUMENT); goto error_exit; } /* ** stage 2 of command line parsing */ ar = lCreateElem(AR_Type); if (!sge_parse_qrsub(ctx, pcmdline, &alp, &ar)) { answer_list_output(&alp); lFreeList(&pcmdline); goto error_exit; } ar_lp = lCreateList(NULL, AR_Type); lAppendElem(ar_lp, ar); alp = ctx->gdi(ctx, SGE_AR_LIST, SGE_GDI_ADD | SGE_GDI_RETURN_NEW_VERSION, &ar_lp, NULL, NULL); lFreeList(&ar_lp); answer_list_on_error_print_or_exit(&alp, stdout); if (answer_list_has_error(&alp)) { sge_gdi2_shutdown((void**)&ctx); sge_prof_cleanup(); if (answer_list_has_status(&alp, STATUS_NOTOK_DOAGAIN)) { DRETURN(25); } else { DRETURN(1); } } sge_gdi2_shutdown((void**)&ctx); sge_prof_cleanup(); DRETURN(0); error_exit: sge_gdi2_shutdown((void**)&ctx); sge_prof_cleanup(); SGE_EXIT((void**)&ctx, 1); DRETURN(1); }