/****** 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;
}
/****** 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;
}
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);
}
/****** uti/monitor/sge_monitor_status() ***************************************
* NAME
* sge_monitor_status() -- generates the status for qping / commlib
*
* SYNOPSIS
* u_long32 sge_monitor_status(char **info_message, u_long32 monitor_time)
*
* FUNCTION
* This method creats the health monitoring output and returns the monitoring
* info to the commlib.
*
* INPUTS
* char **info_message - info_message pointer, has to point to a NULL string
* u_long32 monitor_time - the configured monitoring interval
*
* RESULT
* u_long32 - 0 : everything is okay
* 1 : warning
* 2 : error
* 3 : init problems
*
* NOTES
* MT-NOTE: sge_monitor_status() is MT safe
*
*******************************************************************************/
u_long32 sge_monitor_status(char **info_message, u_long32 monitor_time)
{
u_long32 ret = 0;
char date[40];
dstring ddate;
DENTER(GDI_LAYER, "sge_monitor_status");
if (info_message == NULL) {
DEXIT;
return 3;
}
sge_dstring_init(&ddate, date, sizeof(date));
sge_mutex_lock("sge_monitor_status", SGE_FUNC, __LINE__, &global_mutex);
sge_dstring_clear(&Info_Line);
{/* this is the qping info section, it checks if each thread is still alive */
int i;
int error_count = 0;
struct timeval now;
double time;
char state = 'R';
gettimeofday(&now,NULL);
for (i = 0; i < MAX_OUTPUT_LINES; i++) {
sge_mutex_lock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
if (Output[i].name != NULL) {
time = now.tv_usec - Output[i].last_wait_time.tv_usec;
time = now.tv_sec - Output[i].last_wait_time.tv_sec + (time /1000000);
if (Output[i].warning_timeout != NO_WARNING) {
if (Output[i].warning_timeout < time) {
if (Output[i].error_timeout < time) {
state = 'E';
}
else {
state = 'W';
}
error_count++;
}
}
sge_dstring_sprintf_append(&Info_Line, MSG_UTI_MONITOR_INFO_SCF, Output[i].name, state, time);
}
sge_mutex_unlock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
}
if (error_count == 0) {
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_OK);
}
else if (error_count == 1) {
ret = 1;
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_WARNING);
}
else {
ret = 2;
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_ERROR);
}
sge_dstring_append(&Info_Line, "\n");
}
#if defined(LINUX) || defined(AIX43) || defined(AIX51) || defined(IRIX) || defined(SOLARIS) || defined(HP11)
if (mallinfo_func_pointer != NULL) {
struct mallinfo mallinfo_data = mallinfo_func_pointer();
sge_dstring_sprintf_append(&Info_Line, MSG_UTI_MONITOR_SCHEXT_UUUUUUUUUU,
mallinfo_data.arena,
mallinfo_data.ordblks,
mallinfo_data.smblks,
mallinfo_data.hblks,
mallinfo_data.hblkhd,
mallinfo_data.usmblks,
mallinfo_data.fsmblks,
mallinfo_data.uordblks,
mallinfo_data.fordblks,
mallinfo_data.keepcost);
sge_dstring_append(&Info_Line, "\n");
}
#endif
if (monitor_time != 0) { /* generates the output monitoring output data */
int i;
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_COLON);
sge_dstring_append(&Info_Line, "\n");
for (i = 0; i < MAX_OUTPUT_LINES; i++) {
sge_mutex_lock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
if (Output[i].name != NULL) {
append_time(Output[i].update_time, &Info_Line, false);
sge_dstring_append(&Info_Line, " | ");
sge_dstring_append_dstring(&Info_Line, Output[i].output);
sge_dstring_append(&Info_Line,"\n");
}
sge_mutex_unlock("sge_monitor_status", SGE_FUNC, __LINE__, &(Output[i].Output_Mutex));
}
}
else {
sge_dstring_append(&Info_Line, MSG_UTI_MONITOR_DISABLED);
sge_dstring_append(&Info_Line, "\n");
}
*info_message = strdup(sge_dstring_get_string(&Info_Line));
sge_mutex_unlock("sge_monitor_status", SGE_FUNC, __LINE__, &global_mutex);
DEXIT;
return ret;
}
static bool
check_all(dstring *sb)
{
bool ret = true;
int i;
/* sge_dstring_append */
printf("\nchecking sge_dstring_append\n");
sge_dstring_append(NULL, NULL);
sge_dstring_append(sb, NULL);
check_dstring(sb);
sge_dstring_append(sb, "blah");
check_dstring(sb);
sge_dstring_clear(sb);
sge_dstring_append(sb, "too long string to fit into a static string buffer");
check_dstring(sb);
sge_dstring_clear(sb);
sge_dstring_append(sb,
"long string that requires multiple chunks ....... ");
check_dstring(sb);
for (i = 0; i < 20; i++) {
sge_dstring_append(sb,
"long string that requires multiple chunks ....... ");
}
check_dstring(sb);
/* sge_dstring_append_dstring */
printf("\nchecking sge_dstring_append_dstring\n");
sge_dstring_clear(sb);
sge_dstring_append_dstring(NULL, NULL);
{
dstring second = DSTRING_INIT;
sge_dstring_append(&second, "dstring");
sge_dstring_append_dstring(NULL, &second);
sge_dstring_append_dstring(sb, NULL);
sge_dstring_append_dstring(sb, &second);
check_dstring(sb);
sge_dstring_free(&second);
}
/* sge_dstring_append_char */
printf("\nchecking sge_dstring_append_char\n");
sge_dstring_clear(sb);
sge_dstring_append_char(NULL, 'a');
sge_dstring_append_char(sb, '\0');
check_dstring(sb);
sge_dstring_append_char(sb, 'a');
check_dstring(sb);
sge_dstring_append_char(sb, 'b');
check_dstring(sb);
/* sge_dstring_sprintf */
printf("\nchecking sge_dstring_sprintf\n");
sge_dstring_sprintf(NULL, "test %s", "string");
sge_dstring_sprintf(sb, NULL);
sge_dstring_sprintf(sb, "test %s", "string");
check_dstring(sb);
#if 0
/* does not build on irix */
/* sge_dstring_vsprintf */
printf("\nchecking sge_dstring_vsprintf\n");
{
const char *args[] = { "string", NULL };
sge_dstring_clear(sb);
sge_dstring_vsprintf(NULL, "test %s", args);
sge_dstring_vsprintf(sb, NULL, args);
sge_dstring_vsprintf(sb, "test %s", args);
check_dstring(sb);
}
#endif
/* sge_dstring_sprintf_append */
printf("\nchecking sge_dstring_sprintf_append\n");
sge_dstring_clear(sb);
sge_dstring_sprintf_append(NULL, "test %s", "string");
sge_dstring_sprintf_append(sb, NULL);
sge_dstring_sprintf_append(sb, "test %s", "string");
sge_dstring_sprintf_append(sb, " appended test %s", "string");
check_dstring(sb);
/* sge_dstring_clear */
printf("\nchecking sge_dstring_clear\n");
sge_dstring_clear(NULL);
sge_dstring_clear(sb);
check_dstring(sb);
/* sge_dstring_free */
printf("\nchecking sge_dstring_free\n");
sge_dstring_free(NULL);
sge_dstring_free(sb);
check_dstring(sb);
/* sge_dstring_get_string */
printf("\nchecking sge_dstring_get_string\n");
sge_dstring_clear(sb);
sge_dstring_append(sb, "test string");
{
const char *result;
result = sge_dstring_get_string(NULL);
printf("sge_dstring_get_string(NULL) = %s\n",
result == NULL ? "NULL" : result);
result = sge_dstring_get_string(sb);
printf("sge_dstring_get_string(sb) = %s\n",
result == NULL ? "NULL" : result);
}
/* sge_dstring_copy_string */
printf("\nchecking sge_dstring_copy_string\n");
sge_dstring_copy_string(NULL, NULL);
sge_dstring_copy_string(sb, NULL);
sge_dstring_copy_string(NULL, "new test string");
sge_dstring_copy_string(sb, "new test string");
check_dstring(sb);
/* sge_dstring_copy_dstring
* check only NULL pointer behaviour, it just calls sge_dstring_copy_string
*/
printf("\nchecking sge_dstring_copy_dstring\n");
sge_dstring_copy_dstring(NULL, NULL);
sge_dstring_copy_dstring(sb, NULL);
check_dstring(sb);
/* sge_dstring_strlen */
printf("\nchecking sge_dstring_strlen\n");
{
int len;
sge_dstring_copy_string(sb, "test string");
len = sge_dstring_strlen(NULL);
printf("sge_dstring_strlen(NULL) = %d\n", len);
len = sge_dstring_strlen(sb);
printf("sge_dstring_strlen(sb) = %d\n", len);
}
/* sge_dstring_remaining */
printf("\nchecking sge_dstring_remaining\n");
{
int len;
sge_dstring_copy_string(sb, "test string");
len = sge_dstring_remaining(NULL);
printf("sge_dstring_remaining(NULL) = %d\n", len);
len = sge_dstring_remaining(sb);
printf("sge_dstring_remaining(sb) = %d\n", len);
}
return ret;
}
