コード例 #1
0
ファイル: bhosts.c プロジェクト: ReiAyanamiQH/jhlava
static void
prtHostsShort (int numReply, struct hostInfoEnt  *hInfo)
{
    struct hostInfoEnt *hPtr;
    int i;
    char *status, maxJobs[MAX_CHARLEN], userJobLimit[MAX_CHARLEN];
    char first = TRUE;

    for (i = 0; i < numReply; i++) {
        hPtr = &(hInfo[i]);
        if ( first ) {   
            first = FALSE;
            prtWord(HOST_NAME_LENGTH, 
		_i18n_msg_get(ls_catd, NL_SETN, 1618, "HOST_NAME"), 0); /* catgets  1618  */
	    if ( wflag )
                prtWord(HOST_STATUS_LENGTH, I18N_STATUS, 0);
            else
                prtWord(HOST_STATUS_SHORT, I18N_STATUS, 0);

		if (lsbMode_ & LSB_MODE_BATCH)
                    prtWord(HOST_JL_U_LENGTH, I18N_JL_U, -1);
		
                prtWord(HOST_MAX_LENGTH,   I18N_MAX, -1);
                prtWord(HOST_NJOBS_LENGTH, I18N_NJOBS, -1);
                prtWord(HOST_RUN_LENGTH,   I18N_RUN, -1);
                prtWord(HOST_SSUSP_LENGTH, I18N_SSUSP, -1);
                prtWord(HOST_USUSP_LENGTH, I18N_USUSP, -1);
                prtWord(HOST_RSV_LENGTH,   I18N_RSV, -1);
                printf("\n");
        };

        if ( repeatHost (i, hInfo) )
            continue;

        if ( wflag )  
            prtWordL(HOST_NAME_LENGTH, hPtr->host);
        else
            prtWord(HOST_NAME_LENGTH, hPtr->host, 0);

        status = I18N_ok;
        if (hPtr->hStatus & HOST_STAT_UNAVAIL)
            status = I18N_unavail;
        else if (hPtr->hStatus & HOST_STAT_UNREACH)
            status = (_i18n_msg_get(ls_catd,NL_SETN,1626, "unreach")); /* catgets  1626  */
        else if (hPtr->hStatus & (HOST_STAT_BUSY 
                                             | HOST_STAT_WIND
                                             | HOST_STAT_DISABLED 
                                             | HOST_STAT_EXCLUSIVE
                                             | HOST_STAT_LOCKED
                                             | HOST_STAT_LOCKED_MASTER
                                             | HOST_STAT_FULL
                                             | HOST_STAT_NO_LIM)) {
            if ( !wflag )
                status = (_i18n_msg_get(ls_catd,NL_SETN,1627, "closed")); /* catgets  1627  */
            else
		getCloseString (hPtr->hStatus, &status);
        };

        if ( hPtr->userJobLimit < INFINIT_INT )
            strcpy(userJobLimit, 
                   prtValue(HOST_JL_U_LENGTH, hPtr->userJobLimit));
        else 
            strcpy(userJobLimit,  prtDash(HOST_JL_U_LENGTH));

        if ( hPtr->maxJobs < INFINIT_INT )
            strcpy(maxJobs,
                   prtValue(HOST_MAX_LENGTH, hPtr->maxJobs));
        else 
            strcpy(maxJobs,  prtDash(HOST_MAX_LENGTH));

	if ( wflag )
            prtWordL(HOST_STATUS_LENGTH, status);
	else
            prtWordL(HOST_STATUS_SHORT, status);

	    if ( lsbMode_ & LSB_MODE_BATCH )
		printf("%s", userJobLimit);

            sprintf(fomt, "%%s%%%dd %%%dd %%%dd %%%dd %%%dd\n", 
                                  HOST_NJOBS_LENGTH,
                                  HOST_RUN_LENGTH,
                                  HOST_SSUSP_LENGTH,
                                  HOST_USUSP_LENGTH,
                                  HOST_RSV_LENGTH);
            
            printf(fomt,
                   maxJobs,
		   hPtr->numJobs,
		   hPtr->numRUN, hPtr->numSSUSP, hPtr->numUSUSP,
		   hPtr->numRESERVE);

    }  

} 
コード例 #2
0
ファイル: bqueues.c プロジェクト: ryukun11/openlava
static void
prtQueuesShort(int numQueues, struct queueInfoEnt *queueInfo)
{
    struct queueInfoEnt *qp;
    char statusStr[64];
    char first = FALSE;
    int i;
    char userJobLimit[MAX_CHARLEN],
         procJobLimit[MAX_CHARLEN],
         hostJobLimit[MAX_CHARLEN];
    char maxJobs[MAX_CHARLEN];

    if( !first ) {
        prtWord(QUEUE_NAME_LENGTH, I18N_QUEUE__NAME, 0);
        prtWord(QUEUE_PRIO_LENGTH, I18N_PRIO, 1);
        prtWord(QUEUE_STATUS_LENGTH, I18N_STATUS, 0);

        if ( lsbMode_ & LSB_MODE_BATCH ) {
            prtWord(QUEUE_MAX_LENGTH,  I18N_MAX,  -1);
            prtWord(QUEUE_JL_U_LENGTH, I18N_JL_U, -1);
            prtWord(QUEUE_JL_P_LENGTH, I18N_JL_P, -1);
            prtWord(QUEUE_JL_H_LENGTH, I18N_JL_H, -1);
        };

        prtWord(QUEUE_NJOBS_LENGTH, I18N_NJOBS, -1);
        prtWord(QUEUE_PEND_LENGTH,  I18N_PEND,  -1);
        prtWord(QUEUE_RUN_LENGTH,   I18N_RUN,   -1);
        prtWord(QUEUE_SUSP_LENGTH,  I18N_SUSP,  -1);
        printf("\n");
        first = TRUE;
    }

    for ( i=0; i<numQueues; i++) {

        qp = &(queueInfo[i]);

        if (qp->qStatus & QUEUE_STAT_OPEN) {
            sprintf(statusStr, "%s:", I18N_Open);
        }
        else {
            sprintf(statusStr, "%s:", I18N_Closed);
        }
        if (qp->qStatus & QUEUE_STAT_ACTIVE) {
            if (qp->qStatus & QUEUE_STAT_RUN) {
                strcat(statusStr, I18N_Active);
            } else {
                strcat(statusStr, I18N_Inact);
            }
        } else {
            strcat(statusStr, I18N_Inact);
        }


        if (qp->maxJobs < INFINIT_INT)
            strcpy(maxJobs, prtValue(QUEUE_MAX_LENGTH, qp->maxJobs) );
        else
            strcpy(maxJobs, prtDash(QUEUE_MAX_LENGTH) );


        if (qp->userJobLimit < INFINIT_INT)
            strcpy(userJobLimit,
                   prtValue(QUEUE_JL_U_LENGTH, qp->userJobLimit) );
        else
            strcpy(userJobLimit, prtDash(QUEUE_JL_U_LENGTH) );


        if (qp->procJobLimit < INFINIT_FLOAT) {
            sprintf(fomt, "%%%d.0f ", QUEUE_JL_P_LENGTH);
            sprintf (procJobLimit, fomt, qp->procJobLimit);
        }
        else
            strcpy(procJobLimit, prtDash(QUEUE_JL_P_LENGTH) );

        if (qp->hostJobLimit < INFINIT_INT)
            strcpy(hostJobLimit,
                   prtValue(QUEUE_JL_H_LENGTH, qp->hostJobLimit) );
        else
            strcpy(hostJobLimit, prtDash(QUEUE_JL_H_LENGTH) );

        if (wflag) {
            prtWordL(QUEUE_NAME_LENGTH, qp->queue);
            prtWordL(QUEUE_PRIO_LENGTH,
                     prtValue(3, qp->priority));
            prtWordL(QUEUE_STATUS_LENGTH, statusStr);
        } else {
            prtWord(QUEUE_NAME_LENGTH, qp->queue, 0);
            prtWord(QUEUE_PRIO_LENGTH,
                    prtValue(3, qp->priority), 1);
            prtWord(QUEUE_STATUS_LENGTH, statusStr, 1);
        }

        if ( lsbMode_ & LSB_MODE_BATCH ) {
            sprintf(fomt, "%%%ds%%%ds%%%ds%%%ds", QUEUE_MAX_LENGTH,
                    QUEUE_JL_U_LENGTH,
                    QUEUE_JL_P_LENGTH,
                    QUEUE_JL_H_LENGTH );
            printf(fomt,
                   maxJobs, userJobLimit, procJobLimit, hostJobLimit);
        }

        sprintf(fomt, "%%%dd %%%dd %%%dd %%%dd\n", QUEUE_NJOBS_LENGTH,
                QUEUE_PEND_LENGTH,
                QUEUE_RUN_LENGTH,
                QUEUE_SUSP_LENGTH );
        printf(fomt,
               qp->numJobs, qp->numPEND, qp->numRUN,
               (qp->numSSUSP + qp->numUSUSP) );
    }
}
コード例 #3
0
ファイル: bhosts.c プロジェクト: ReiAyanamiQH/jhlava
static void
prtHostsLong (int numReply, struct hostInfoEnt  *hInfo)
{
    struct hostInfoEnt *hPtr;
    int i, j, retVal = 0;
    char *status, maxJobs[MAX_CHARLEN], userJobLimit[MAX_CHARLEN];
    char **nameTable, **totalValues, **rsvValues, **formats;
    struct lsInfo *lsInfo;
   
    if ((lsInfo = ls_info()) == NULL) {
	ls_perror("ls_info");
	exit(-1);
    }
    
    lsInfoPtr = lsInfo;

    for (i = 0; i < numReply; i++) {
	hPtr = &(hInfo[i]);
        if (repeatHost (i, hInfo))
            continue;
	printf("%s  %s\n",
		(_i18n_msg_get(ls_catd,NL_SETN,1604, "HOST")), /* catgets  1604  */
		hPtr->host); 

	
        prtWord(HOST_STATUS_LENGTH, I18N_STATUS, 0);

	if (lsbMode_ & LSB_MODE_BATCH) {
            prtWord(HOST_CPUF_LENGTH, I18N_CPUF, -1);
            prtWord(HOST_JL_U_LENGTH, I18N_JL_U, -1);
	};

            prtWord(HOST_MAX_LENGTH,   I18N_MAX, -1);
            prtWord(HOST_NJOBS_LENGTH, I18N_NJOBS, -1);
            prtWord(HOST_RUN_LENGTH,   I18N_RUN, -1);
            prtWord(HOST_SSUSP_LENGTH, I18N_SSUSP, -1);
            prtWord(HOST_USUSP_LENGTH, I18N_USUSP, -1);
            prtWord(HOST_RSV_LENGTH,   I18N_RSV, -1);

	if (lsbMode_ & LSB_MODE_BATCH)
	    printf(I18N(1608, "DISPATCH_WINDOW\n")); /* catgets  1608  */
	else
	    printf("\n");
	
	status = I18N_ok; 
	if (hPtr->hStatus & HOST_STAT_UNAVAIL)
	    status = I18N_unavail; 
	else if (hPtr->hStatus & HOST_STAT_UNREACH)
	    status = (_i18n_msg_get(ls_catd,NL_SETN,1611, "unreach")); /* catgets  1611  */
      
        else if (hPtr->hStatus & (HOST_STAT_BUSY
                                             | HOST_STAT_WIND
                                             | HOST_STAT_DISABLED
                                             | HOST_STAT_EXCLUSIVE
                                             | HOST_STAT_LOCKED
                                             | HOST_STAT_LOCKED_MASTER
                                             | HOST_STAT_FULL
                                             | HOST_STAT_NO_LIM)) 
            getCloseString (hPtr->hStatus, &status);

	if (hPtr->userJobLimit < INFINIT_INT)   
            strcpy(userJobLimit, 
                   prtValue(HOST_JL_U_LENGTH, hPtr->userJobLimit));
        else 
            strcpy(userJobLimit,  prtDash(HOST_JL_U_LENGTH));

        if ( hPtr->maxJobs < INFINIT_INT )
            strcpy(maxJobs,
                   prtValue(HOST_MAX_LENGTH, hPtr->maxJobs));
        else 
            strcpy(maxJobs,  prtDash(HOST_MAX_LENGTH));

        prtWordL(HOST_STATUS_LENGTH, status);

	if (lsbMode_ & LSB_MODE_BATCH) {
            sprintf(fomt, "%%%d.2f %%s", HOST_CPUF_LENGTH );
	    printf(fomt, hPtr->cpuFactor, userJobLimit);
	};


            sprintf(fomt, "%%s%%%dd %%%dd %%%dd %%%dd %%%dd ", 
                                  HOST_NJOBS_LENGTH,
                                  HOST_RUN_LENGTH,
                                  HOST_SSUSP_LENGTH,
                                  HOST_USUSP_LENGTH,
                                  HOST_RSV_LENGTH);
            
            printf(fomt,
                   maxJobs, hPtr->numJobs, hPtr->numRUN, 
		   hPtr->numSSUSP, hPtr->numUSUSP, hPtr->numRESERVE);

	if (lsbMode_ & LSB_MODE_BATCH)	    
	    printf("%s\n\n",	
		   hPtr->windows[0] != '\0' ? hPtr->windows : "     -");
	else
	    printf("\n\n");	    

	if (!(hPtr->hStatus & (HOST_STAT_UNAVAIL | HOST_STAT_UNREACH))){ 
	    printf(" %s:\n",
		_i18n_msg_get(ls_catd,NL_SETN,1612, "CURRENT LOAD USED FOR SCHEDULING")); /* catgets  1612  */
	    prtLoad(hPtr, lsInfo);

	    if (lsbSharedResConfigured_) {
		
		retVal = makeShareFields(hPtr->host, lsInfo, &nameTable, 
					 &totalValues, &rsvValues,
					 &formats); 
		if (retVal > 0) {
		    int start =0;
		    int end;
                    while ((end = getDispLastItem(nameTable, start, retVal)) > start 
	                   && start < retVal) { 
		        printf(" %11s", " ");
		        for (j = start; j < end; j++) 
                            printf(formats[j], nameTable[j]);
		    
		        printf("\n %-11.11s",
                               _i18n_msg_get(ls_catd,NL_SETN,1613, "Total"));   /* catgets  1613  */
	                for (j = start; j < end; j++) 
                            printf(formats[j], totalValues[j]);

		        printf("\n %-11.11s",
                               _i18n_msg_get(ls_catd,NL_SETN,1614, "Reserved"));  /* catgets 1614 */
		        for (j = start; j < end; j++) 
                            printf(formats[j], rsvValues[j]);
		        putchar('\n');
		        putchar('\n');
			start = end;
                    }
		    putchar('\n');
		}
	    }
	}
	printf(" %s:\n",
	    _i18n_msg_get(ls_catd,NL_SETN,1615, "LOAD THRESHOLD USED FOR SCHEDULING"));	 /* catgets  1615  */
	if (printThresholds(hPtr->loadSched, hPtr->loadStop, 
			    hPtr->busySched, hPtr->busyStop,
			    MIN(hInfo->nIdx, lsInfo->numIndx),
			    lsInfo) < 0)
	    continue;
	printf("\n");
	
        
	if (hPtr->mig < INFINIT_INT) 
	    printf(( _i18n_msg_get(ls_catd, NL_SETN, 1616, "Migration threshold is %d min \n")), hPtr->mig);  /* catgets  1616  */

        printf("\n");
    } 
} 
コード例 #4
0
ファイル: bqueues.c プロジェクト: ryukun11/openlava
static void
prtQueuesLong(int numQueues, struct queueInfoEnt *queueInfo)
{
    struct queueInfoEnt   *qp;
    char                  statusStr[64];
    char                  userJobLimit[MAX_CHARLEN];
    char                  procJobLimit[MAX_CHARLEN];
    char                  hostJobLimit[MAX_CHARLEN];
    char                  maxJobs[MAX_CHARLEN];
    int                   i;
    int                   numDefaults = 0;
    struct lsInfo         *lsInfo;
    int                   printFlag = 0;
    int                   printFlag1 = 0;
    int                   printFlag2 = 0;
    int                   procLimits[3];

    if ((lsInfo = ls_info()) == NULL) {
        ls_perror("ls_info");
        exit(-1);
    }

    printf("\n");

    for (i = 0; i < numQueues; i++ )  {
        qp = &(queueInfo[i]);
        if (qp->qAttrib & Q_ATTRIB_DEFAULT)
            numDefaults++;
    }

    for (i = 0; i < numQueues; i++) {

        qp = &(queueInfo[i]);

        if (qp->qStatus & QUEUE_STAT_OPEN) {
            sprintf(statusStr, "%s:", I18N_Open);
        }
        else {
            sprintf(statusStr, "%s:", I18N_Closed);
        }
        if (qp->qStatus & QUEUE_STAT_ACTIVE) {
            if (qp->qStatus & QUEUE_STAT_RUN) {
                strcat(statusStr, I18N_Active);
            } else {
                strcat(statusStr, I18N_Inact__Win);
            }
        } else {
            strcat(statusStr, I18N_Inact__Adm);
        }


        if (qp->maxJobs < INFINIT_INT)
            strcpy(maxJobs, prtValue(QUEUE_MAX_LENGTH, qp->maxJobs) );
        else
            strcpy(maxJobs, prtDash(QUEUE_MAX_LENGTH) );


        if (qp->userJobLimit < INFINIT_INT)
            strcpy(userJobLimit,
                   prtValue(QUEUE_JL_U_LENGTH, qp->userJobLimit) );
        else
            strcpy(userJobLimit, prtDash(QUEUE_JL_U_LENGTH) );


        if (qp->procJobLimit < INFINIT_FLOAT) {
            sprintf(fomt, "%%%d.1f ", QUEUE_JL_P_LENGTH);
            sprintf (procJobLimit, fomt, qp->procJobLimit);
        }
        else
            strcpy(procJobLimit, prtDash(QUEUE_JL_P_LENGTH) );


        if (qp->hostJobLimit < INFINIT_INT)
            strcpy(hostJobLimit,
                   prtValue(QUEUE_JL_H_LENGTH, qp->hostJobLimit) );
        else
            strcpy(hostJobLimit, prtDash(QUEUE_JL_H_LENGTH) );

        if (i > 0)
            printf("-------------------------------------------------------------------------------\n\n");
        printf("%s: %s\n", _i18n_msg_get(ls_catd,NL_SETN,1210,
                                         "QUEUE"), qp->queue); /* catgets  1210  */

        printf("  -- %s", qp->description);
        if (qp->qAttrib & Q_ATTRIB_DEFAULT) {
            if (numDefaults == 1)
                printf("  %s.\n\n", _i18n_msg_get(ls_catd,NL_SETN,1211,
                                                  "This is the default queue")); /* catgets  1211  */
            else
                printf("  %s.\n\n", _i18n_msg_get(ls_catd,NL_SETN,1212,
                                                  "This is one of the default queues")); /* catgets  1212  */
        } else
            printf("\n\n");

        printf((_i18n_msg_get(ls_catd,NL_SETN,1213, "PARAMETERS/STATISTICS\n"))); /* catgets  1213  */

        prtWord(QUEUE_PRIO_LENGTH, I18N_PRIO, 0);

        if ( lsbMode_ & LSB_MODE_BATCH )
            prtWord(QUEUE_NICE_LENGTH, I18N_NICE, 1);

        prtWord(QUEUE_STATUS_LENGTH, I18N_STATUS, 0);

        if ( lsbMode_ & LSB_MODE_BATCH ) {
            prtWord(QUEUE_MAX_LENGTH,  I18N_MAX, -1);
            prtWord(QUEUE_JL_U_LENGTH, I18N_JL_U, -1);
            prtWord(QUEUE_JL_P_LENGTH, I18N_JL_P, -1);
            prtWord(QUEUE_JL_H_LENGTH, I18N_JL_H, -1);
        };

        prtWord(QUEUE_NJOBS_LENGTH, I18N_NJOBS, -1);
        prtWord(QUEUE_PEND_LENGTH,  I18N_PEND,  -1);
        prtWord(QUEUE_RUN_LENGTH,   I18N_RUN,   -1);
        prtWord(QUEUE_SSUSP_LENGTH, I18N_SSUSP, -1);
        prtWord(QUEUE_USUSP_LENGTH, I18N_USUSP, -1);
        prtWord(QUEUE_RSV_LENGTH,   I18N_RSV,   -1);
        printf("\n");

        prtWordL(QUEUE_PRIO_LENGTH,
                 prtValue(QUEUE_PRIO_LENGTH-1, qp->priority));

        if ( lsbMode_ & LSB_MODE_BATCH )
            prtWordL(QUEUE_NICE_LENGTH,
                     prtValue(QUEUE_NICE_LENGTH-1, qp->nice));

        prtWord(QUEUE_STATUS_LENGTH, statusStr, 0);

        if ( lsbMode_ & LSB_MODE_BATCH ) {
            sprintf(fomt, "%%%ds%%%ds%%%ds%%%ds", QUEUE_MAX_LENGTH,
                    QUEUE_JL_U_LENGTH,
                    QUEUE_JL_P_LENGTH,
                    QUEUE_JL_H_LENGTH );
            printf(fomt,
                   maxJobs, userJobLimit, procJobLimit, hostJobLimit);
        };

        sprintf(fomt, "%%%dd %%%dd %%%dd %%%dd %%%dd %%%dd\n",
                QUEUE_NJOBS_LENGTH,
                QUEUE_PEND_LENGTH,
                QUEUE_RUN_LENGTH,
                QUEUE_SSUSP_LENGTH,
                QUEUE_USUSP_LENGTH,
                QUEUE_RSV_LENGTH );
        printf(fomt,
               qp->numJobs, qp->numPEND, qp->numRUN,
               qp->numSSUSP, qp->numUSUSP, qp->numRESERVE);

        if ( qp->mig < INFINIT_INT )
            printf((_i18n_msg_get(ls_catd,NL_SETN,1215,
                                  "Migration threshold is %d minutes\n")), qp->mig); /* catgets  1215  */

        if ( qp->schedDelay < INFINIT_INT )
            printf((_i18n_msg_get(ls_catd,NL_SETN,1216, "Schedule delay for a new job is %d seconds\n")),  /* catgets  1216  */
                   qp->schedDelay);

        if ( qp->acceptIntvl < INFINIT_INT )
            printf((_i18n_msg_get(ls_catd,NL_SETN,1217, "Interval for a host to accept two jobs is %d seconds\n")), /* catgets  1217  */
                   qp->acceptIntvl);

        if (((qp->defLimits[LSF_RLIMIT_CPU] != INFINIT_INT) &&
                (qp->defLimits[LSF_RLIMIT_CPU] > 0 )) ||
                ((qp->defLimits[LSF_RLIMIT_RUN] != INFINIT_INT) &&
                 (qp->defLimits[LSF_RLIMIT_RUN] > 0 )) ||
                ((qp->defLimits[LSF_RLIMIT_DATA] != INFINIT_INT) &&
                 (qp->defLimits[LSF_RLIMIT_DATA] > 0 )) ||
                ((qp->defLimits[LSF_RLIMIT_RSS] != INFINIT_INT) &&
                 (qp->defLimits[LSF_RLIMIT_RSS] > 0 )) ||
                ((qp->defLimits[LSF_RLIMIT_PROCESS] != INFINIT_INT) &&
                 (qp->defLimits[LSF_RLIMIT_PROCESS] > 0 ))) {


            printf("\n");
            printf(_i18n_msg_get(ls_catd,NL_SETN,1270,
                                 "DEFAULT LIMITS:") /* catgets 1270 */ );
            prtResourceLimit (qp->defLimits, qp->hostSpec, 1.0, 0);
            printf("\n");
            printf(_i18n_msg_get(ls_catd,NL_SETN,1271,
                                 "MAXIMUM LIMITS:") /* catgets 1271 */ );
        }

        procLimits[0] = qp->minProcLimit;
        procLimits[1] = qp->defProcLimit;
        procLimits[2] = qp->procLimit;
        prtResourceLimit (qp->rLimits, qp->hostSpec, 1.0, procLimits);

        if ( lsbMode_ & LSB_MODE_BATCH ) {
            printf((_i18n_msg_get(ls_catd,NL_SETN,1218, "\nSCHEDULING PARAMETERS\n")));  /* catgets 1218 */

            if (printThresholds (qp->loadSched,  qp->loadStop, NULL, NULL,
                                 MIN(lsInfo->numIndx, qp->nIdx), lsInfo) < 0)
                exit (-1);
        }

        if ((qp->qAttrib & Q_ATTRIB_EXCLUSIVE)
                || (qp->qAttrib & Q_ATTRIB_BACKFILL)
                || (qp->qAttrib & Q_ATTRIB_IGNORE_DEADLINE)
                || (qp->qAttrib & Q_ATTRIB_ONLY_INTERACTIVE)
                || (qp->qAttrib & Q_ATTRIB_NO_INTERACTIVE)) {

            printf("\n%s:", _i18n_msg_get(ls_catd,NL_SETN,1219,
                                          "SCHEDULING POLICIES")); /* catgets  1219  */
            if (qp->qAttrib & Q_ATTRIB_BACKFILL)
                printf("  %s", (_i18n_msg_get(ls_catd,NL_SETN,1223,
                                              "BACKFILL"))); /* catgets  1223  */
            if (qp->qAttrib & Q_ATTRIB_IGNORE_DEADLINE)
                printf("  %s", (_i18n_msg_get(ls_catd,NL_SETN,1224,
                                              "IGNORE_DEADLINE"))); /* catgets  1224  */
            if (qp->qAttrib & Q_ATTRIB_EXCLUSIVE)
                printf("  %s", (_i18n_msg_get(ls_catd,NL_SETN,1225,
                                              "EXCLUSIVE"))); /* catgets  1225  */
            if (qp->qAttrib & Q_ATTRIB_NO_INTERACTIVE)
                printf("  %s", (_i18n_msg_get(ls_catd,NL_SETN,1226,
                                              "NO_INTERACTIVE"))); /* catgets  1226  */
            if (qp->qAttrib & Q_ATTRIB_ONLY_INTERACTIVE)
                printf("  %s", (_i18n_msg_get(ls_catd,NL_SETN,1227,
                                              "ONLY_INTERACTIVE")));                   /* catgets  1227  */
            printf("\n");
        }

        if (strcmp (qp->defaultHostSpec, " ") !=  0)
            printf("\n%s: %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1230, "DEFAULT HOST SPECIFICATION")), qp->defaultHostSpec); /* catgets  1230  */

        if (qp->windows && strcmp (qp->windows, " " ) !=0)
            printf("\n%s: %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1231, "RUN_WINDOW")), qp->windows); /* catgets  1231  */
        if (strcmp (qp->windowsD, " ")  !=  0)
            printf("\n%s: %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1232, "DISPATCH_WINDOW")), qp->windowsD); /* catgets  1232  */

        if (lsbMode_ & LSB_MODE_BATCH) {
            if ( strcmp(qp->userList, " ") == 0) {
                printf("\n%s:  %s\n", I18N_USERS,
                       I18N(408, "all users")); /* catgets 408 */
            } else {
                if (strcmp(qp->userList, " ") != 0 && qp->userList[0] != 0)
                    printf("\n%s: %s\n", I18N_USERS, qp->userList);
            }
        }

        if (strcmp(qp->hostList, " ") == 0) {
            if (lsbMode_ & LSB_MODE_BATCH)
                printf("%s\n",
                       (_i18n_msg_get(ls_catd,NL_SETN,1235, "HOSTS:  all hosts used by the LSF Batch system"))); /* catgets  1235  */
            else
                printf("%s\n",
                       (_i18n_msg_get(ls_catd,NL_SETN,1236, "HOSTS: all hosts used by the LSF JobScheduler system"))); /* catgets  1236  */
        } else {
            if (strcmp(qp->hostList, " ") != 0 && qp->hostList[0])
                printf("%s:  %s\n", I18N_HOSTS, qp->hostList);
        }
        if (strcmp (qp->prepostUsername, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1238, "PRE_POST_EXEC_USER")), qp->prepostUsername); /* catgets  1238  */
        if (strcmp (qp->admins, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1239, "ADMINISTRATORS")), qp->admins); /* catgets  1239  */
        if (strcmp (qp->preCmd, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1240, "PRE_EXEC")), qp->preCmd); /* catgets  1240  */
        if (strcmp (qp->postCmd, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1241, "POST_EXEC")), qp->postCmd); /* catgets  1241  */
        if (strcmp (qp->requeueEValues, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1242, "REQUEUE_EXIT_VALUES")), qp->requeueEValues); /* catgets  1242  */
        if (strcmp (qp->resReq, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1243, "RES_REQ")), qp->resReq); /* catgets  1243  */
        if (qp->slotHoldTime > 0)
            printf((_i18n_msg_get(ls_catd,NL_SETN,1244, "Maximum slot reservation time: %d seconds\n")), qp->slotHoldTime); /* catgets  1244  */
        if (strcmp (qp->resumeCond, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1245, "RESUME_COND")), qp->resumeCond); /* catgets  1245  */
        if (strcmp (qp->stopCond, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1246, "STOP_COND")), qp->stopCond); /* catgets  1246  */
        if (strcmp (qp->jobStarter, " ") != 0)
            printf("%s:  %s\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1247, "JOB_STARTER")), qp->jobStarter);   /* catgets  1247  */
        if (qp->qAttrib & Q_ATTRIB_RERUNNABLE)
            printf("RERUNNABLE :  yes\n");

        if ( qp->qAttrib & Q_ATTRIB_CHKPNT ) {
            printf((_i18n_msg_get(ls_catd,NL_SETN,1261, "CHKPNTDIR : %s\n")), qp->chkpntDir); /* catgets  1261  */
            printf((_i18n_msg_get(ls_catd,NL_SETN,1262, "CHKPNTPERIOD : %d\n")), qp->chkpntPeriod); /* catgets  1262  */
        }

        if (qp->qAttrib & Q_ATTRIB_ROUND_ROBIN)
            printf("ROUN_ROBIN_SCHEDULING:  yes\n");

        printf("\n");
        printFlag = 0;
        if  ((qp->suspendActCmd != NULL)
                && (qp->suspendActCmd[0] != ' '))
            printFlag = 1;

        printFlag1 = 0;
        if  ((qp->resumeActCmd != NULL)
                && (qp->resumeActCmd[0] != ' '))
            printFlag1 = 1;

        printFlag2 = 0;
        if  ((qp->terminateActCmd != NULL)
                && (qp->terminateActCmd[0] != ' '))
            printFlag2 = 1;

        if (printFlag || printFlag1 || printFlag2)
            printf("%s:\n",
                   (_i18n_msg_get(ls_catd,NL_SETN,1251, "JOB_CONTROLS"))); /* catgets  1251  */

        if (printFlag) {
            printf("    %-9.9s", (_i18n_msg_get(ls_catd,NL_SETN,1252, "SUSPEND:"))); /* catgets  1252  */
            if (strcmp (qp->suspendActCmd, " ") != 0)
                printf("    [%s]\n", qp->suspendActCmd);
        }

        if (printFlag1) {
            printf("    %-9.9s", (_i18n_msg_get(ls_catd,NL_SETN,1253, "RESUME:"))); /* catgets  1253  */
            if (strcmp (qp->resumeActCmd, " ") != 0)
                printf("    [%s]\n", qp->resumeActCmd);
        }

        if (printFlag2) {
            printf("    %-9.9s", (_i18n_msg_get(ls_catd,NL_SETN,1254, "TERMINATE:"))); /* catgets  1254  */
            if (strcmp (qp->terminateActCmd, " ") != 0)
                printf("    [%s]\n", qp->terminateActCmd);
        }

        if (printFlag || printFlag1 || printFlag2)
            printf("\n");

        printFlag = terminateWhen_(qp->sigMap, "USER");
        printFlag1 = terminateWhen_(qp->sigMap, "WINDOW");
        printFlag2 = terminateWhen_(qp->sigMap, "LOAD");

        if (printFlag | printFlag1 | printFlag2) {
            printf((_i18n_msg_get(ls_catd,NL_SETN,1255, "TERMINATE_WHEN = "))); /* catgets  1255  */
            if (printFlag) printf((_i18n_msg_get(ls_catd,NL_SETN,1256, "USER "))); /* catgets  1256  */
            if (printFlag1) printf((_i18n_msg_get(ls_catd,NL_SETN,1258, "WINDOW "))); /* catgets  1258  */
            if (printFlag2) printf((_i18n_msg_get(ls_catd,NL_SETN,1259, "LOAD"))); /* catgets  1259  */
            printf("\n");
        }
    }

    printf("\n");

}