void main(
int argc,
char **argv
) {
printf(MSG_INFO_NUMBOFPROCESSORS_I, sge_nprocs());
printf("\n");
exit(0);
}
/****** shepherd/pset/range2proc_vec() ****************************************
* NAME
* range2proc_vec() -- Computes bit vector (prcessor set spec.)
*
* SYNOPSIS
* static int range2proc_vec(char *crange, sbv_t *proc_vec, char *err_str)
*
* FUNCTION
* Computes bit vector with bits set corresponding to string
* specification of processor range.
*
* INPUTS
* char *crange - String specifier of the range. Will be modified
* internally. Format:
* n|[n][-[m]],... , n,m being int >= 0.
* no blanks are allowed in between
* sbv_t *proc_vec - a bit vector of type sbv_t with all bits set
* contained in the range description and all
* other bits zero.
* char *err_str - The error message string to be used by the
* calling routine if return value != PROC_SET_OK.
* Also used for trace messages internally.
*
* RESULT
* static int - Error state
* PROC_SET_OK - Ok
* PROC_SET_ERROR - Invalid range value in range description.
******************************************************************************/
static int range2proc_vec(char *crange, sbv_t *proc_vec, char *err_str)
{
char *tok, *next, *p=crange;
int min, max, i;
int dash_used;
int sbvlen;
*proc_vec = (sbv_t) 0;
/* compute max number of processors and thus significant length of
* proc_vec
*/
sbvlen = sge_nprocs() - 1; /* LSB corresponds to proc. 0 */
/* loop trough range string with "," as token delimiter
* Set processor vector for each token = range definition element.
*/
while ((tok=strtok(p,","))) {
if (p) p=NULL;
/* for each token parse range, i.e. find
* whether min or max value is set and whether a "-" sign
* was used
*/
min = -1;
max = -1;
dash_used = 0;
while (*tok) {
next = NULL;
if (*tok == '-') {
dash_used = 1;
if (min == -1)
min = 0;
} else { /* should be a number */
if (min == -1 && !dash_used ) {
min = (int) strtol(tok, &next, 10);
if (next == tok || min < 0 || min > sbvlen) {
sprintf(err_str, "range2proc_vec: wrong processor range format: %20.20s", crange);
shepherd_trace(err_str);
return PROC_SET_ERROR;
}
} else if (max == -1 && dash_used ) {
max = (int) strtol(tok, &next, 10);
if (next == tok || max < 0 || max > sbvlen) {
sprintf(err_str, "range2proc_vec: wrong processor range format: %20.20s", crange);
shepherd_trace(err_str);
return PROC_SET_ERROR;
}
}
}
/* proceed either by one char in case of a "-" or by the
* width of the number field
*/
if (next)
tok = next;
else
tok++;
}
/* fill out full range specification "n-m" according to findings */
if (!dash_used )
max = min;
else {
if (min == -1) min = 0;
if (max == -1) max = sbvlen;
}
/* set processor vector as defined by range specification */
for(i=min; i<=max; i++)
*proc_vec |= (sbv_t) 1<<i;
}
return PROC_SET_OK;
}
int main(int argc, char *argv[])
{
double avg[3];
int loads;
char *name = NULL;
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
dstring msocket = DSTRING_INIT;
dstring mcore = DSTRING_INIT;
dstring mtopology = DSTRING_INIT;
#endif
#ifdef SGE_LOADMEM
sge_mem_info_t mem_info;
#endif
#ifdef SGE_LOADCPU
double total = 0.0;
#endif
int i, pos = 0, print_as_int = 0, precision = 0, core_binding = 0;
char *m = "";
#ifndef WINDOWS
DENTER_MAIN(TOP_LAYER, "loadcheck");
#endif
#ifdef __SGE_COMPILE_WITH_GETTEXT__
/* init language output for gettext() , it will use the right language */
sge_init_language_func((gettext_func_type) gettext,
(setlocale_func_type) setlocale,
(bindtextdomain_func_type) bindtextdomain,
(textdomain_func_type) textdomain);
sge_init_language(NULL,NULL);
#endif /* __SGE_COMPILE_WITH_GETTEXT__ */
if (argc == 2 && !strcmp(argv[1], "-cb")) {
core_binding = 1;
} else {
for (i = 1; i < argc;) {
if (!strcmp(argv[i], "-int"))
print_as_int = 1;
else if (!strcmp(argv[i], "-loadval")) {
if (i + 1 < argc)
pos=i+1;
else
usage();
i++;
}
else
usage();
i++;
}
}
if (core_binding) {
check_core_binding();
#ifndef WINDOWS
DEXIT;
#endif
return 1;
} else if (print_as_int) {
m = "";
precision = 0;
}
else {
m = "M";
precision = 6;
}
if ((pos && !strcmp("arch", argv[pos])) || !pos) {
const char *arch = "";
#if defined(WINDOWS)
arch = "win32-x86";
#else
arch = sge_get_arch();
#endif
printf("arch %s\n", arch);
}
if ((pos && !strcmp("num_proc", argv[pos])) || !pos) {
int nprocs = 1;
#if defined(WINDOWS)
SYSTEM_INFO system_info;
char buf[100];
GetSystemInfo(&system_info);
nprocs = system_info.dwNumberOfProcessors;
sprintf(buf, "num_proc %d", nprocs);
fflush(stdout);
write(1, (const void*)buf, (unsigned int)strlen(buf));
write(1, (const void*)"\0x0a", (unsigned int)1);
#else
nprocs = sge_nprocs();
printf("num_proc %d\n", nprocs);
#endif
}
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
fill_socket_core_topology(&msocket, &mcore, &mtopology);
if ((pos && !strcmp("m_socket", argv[pos])) || !pos) {
printf("m_socket %s\n", sge_dstring_get_string(&msocket));
}
if ((pos && !strcmp("m_core", argv[pos])) || !pos) {
printf("m_core %s\n", sge_dstring_get_string(&mcore));
}
if ((pos && !strcmp("m_topology", argv[pos])) || !pos) {
printf("m_topology %s\n", sge_dstring_get_string(&mtopology));
}
#else
if ((pos && !strcmp("m_socket", argv[pos])) || !pos) {
printf("m_socket -\n");
}
if ((pos && !strcmp("m_core", argv[pos])) || !pos) {
printf("m_core -\n");
}
if ((pos && !strcmp("m_topology", argv[pos])) || !pos) {
printf("m_topology -\n");
}
#endif
#if defined(WINDOWS)
loads = 0;
avg[0] = avg[1] = avg[2] = 0;
#else
loads = sge_getloadavg(avg, 3);
#endif
if (loads>0 && ((pos && !strcmp("load_short", argv[pos])) || !pos))
printf("load_short %.2f\n", avg[0]);
if (loads>1 && ((pos && !strcmp("load_medium", argv[pos])) || !pos))
printf("load_medium %.2f\n", avg[1]);
if (loads>2 && ((pos && !strcmp("load_long", argv[pos])) || !pos))
printf("load_long %.2f\n", avg[2]);
if (pos)
name = argv[pos];
else
name = NULL;
#ifdef SGE_LOADMEM
/* memory load report */
memset(&mem_info, 0, sizeof(sge_mem_info_t));
if (sge_loadmem(&mem_info)) {
fprintf(stderr, "%s\n", MSG_SYSTEM_RETMEMORYINDICESFAILED);
#ifndef WINDOWS
DEXIT;
#endif
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
sge_dstring_free(&mcore);
sge_dstring_free(&msocket);
sge_dstring_free(&mtopology);
#endif
return 1;
}
print_mem_load(LOAD_ATTR_MEM_FREE, name, precision, mem_info.mem_free, m);
print_mem_load(LOAD_ATTR_SWAP_FREE, name, precision, mem_info.swap_free, m);
print_mem_load(LOAD_ATTR_VIRTUAL_FREE, name, precision, mem_info.mem_free + mem_info.swap_free, m);
print_mem_load(LOAD_ATTR_MEM_TOTAL, name, precision, mem_info.mem_total, m);
print_mem_load(LOAD_ATTR_SWAP_TOTAL, name, precision, mem_info.swap_total, m);
print_mem_load(LOAD_ATTR_VIRTUAL_TOTAL, name, precision, mem_info.mem_total + mem_info.swap_total, m);
print_mem_load(LOAD_ATTR_MEM_USED, name, precision, mem_info.mem_total - mem_info.mem_free, m);
print_mem_load(LOAD_ATTR_SWAP_USED, name, precision, mem_info.swap_total - mem_info.swap_free, m);
print_mem_load(LOAD_ATTR_VIRTUAL_USED, name, precision,(mem_info.mem_total + mem_info.swap_total) -
(mem_info.mem_free + mem_info.swap_free), m);
# ifdef IRIX
print_mem_load(LOAD_ATTR_SWAP_USED, name, precision, mem_info.swap_rsvd, m);
# endif
#endif /* SGE_LOADMEM */
#ifdef SGE_LOADCPU
loads = sge_getcpuload(&total);
sleep(1);
loads = sge_getcpuload(&total);
if (loads != -1) {
print_mem_load("cpu", name, 1, total, "%");
}
#endif /* SGE_LOADCPU */
#ifndef WINDOWS
DEXIT;
#endif
#if defined(PLPA_LINUX) || defined(BINDING_SOLARIS)
sge_dstring_free(&mcore);
sge_dstring_free(&msocket);
sge_dstring_free(&mtopology);
#endif
return 0;
}