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);
}
