Verfassen von anwenderdefinierten Ressourcenzuteilungsregeln

Die Reihenfolgeplanung entscheidet anhand der Ressourcenzuteilungsregeln, welche Ressourcen einer Ressourcengruppe bei der Zuteilung der Ressourcen zu einer Ladung verwendet werden. Sie werden auch bei der Neuzuteilung von Ressourcen zugrunde gelegt, wenn die Option Neuzuteilung für die Gruppe aktiviert wurde.
Hinweis:  Eine Zusammenfassung der beim Erstellen anwenderdefinierter Regeln durchzuführenden Schritte finden Sie unter Verfassen von anwenderdefinierten Reihenfolgeplanungs-Regeln. Weitere Informationen zu den in diesem Thema beschriebenen Funktionen finden Sie im Handbuch für die Anpassung der Reihenfolgeplanung, das Sie von unserer Support-Website herunterladen können.

Benennen der Funktion

Sie können einen beliebigen Namen für die Funktion wählen, solange es sich nicht um den Namen einer von Anwendern aufrufbaren Standardfunktion handelt.

Argumente


#include "factor.h"
void myrule(gp, nu, ldp, mlist)
RESGRP    *gp;   /* pointer to resource group. */
int        nu;   /* number of units required.  */
LOAD     *ldp;   /* pointer to the load.       */
CSLIST *mlist;   /* current selection list.    */

Die Funktion muss vier Argumente in der folgenden Reihenfolge akzeptieren:

  1. Einen Zeiger auf die Ressourcengruppe (Typ: RESGRP*).
  2. Eine Ganzzahl für die Anzahl der Ressourcen, die aus dieser Gruppe für die Zuordnung ausgewählt werden sollen (Typ: int).
  3. Einen Zeiger auf die Auslastung, die eine Ressourcenzuordnung aus dieser Gruppe anfordert (Typ: LOAD*.)
  4. Eine Liste, die mit RMTAGS von Ressourcen gefüllt wird, die aus dieser Gruppe für die Zuordnung ausgewählt wurden (Typ: CSLIST*).

Hinzufügen und Entfernen von Gruppenmitgliedern

Sie können Gruppenmitglieder zur Liste der ausgewählten Ressourcen (mlist) hinzufügen oder aus der Liste entfernen, indem Sie die Systemunterstützungsfunktionen seadsl und sermsl verwenden. Zum Hinzufügen von Gruppenmitgliedern zur Liste verwenden Sie die Funktion seadsl wie folgt: 


void seadsl(CSLIST *mlist, RESMEMB *rmp)

Um Gruppenmitglieder aus der Liste zu entfernen, verwenden Sie die Funktion sermsl wie folgt: 


void sermsl(CSLIST *mlist, RMTAG *rmt)

Rückgabewerte

Die Funktion soll keinen Wert zurückgeben (Typ: storniert).

In dem folgenden Beispiel wird eine Regel für die Auswahl verfügbarer Ressourcengruppenmitglieder auf der Grundlage der kleinsten mittleren Auslastung definiert: 


void rgsr (RESGRP *gp, int nu, LOAD *ldp, CSLIST *mlist)
/*-----------------------------------------------------------------
     Function to process resource group selection code 3, select
     required number of member resources that have the least mean
     utilizations (as a fraction of capacity).
     NOTES:
     * Ties are broken by selecting the first in the order listed
       in the group.
     * This function requires that resource statistics be enabled.
       Any resource which does not have statistics enabled is
       assumed to have a utilization of zero.   Thus if all
       resource statistics are disabled, this defaults to
       rule 0.
     * This function uses seaars, which includes must complete and
       maxOT in its considerations, to determine the availability
       of each member resource.
     ARGS:
       gp    - pointer to resource group to select member from
       nu    - number of units required from selected member
       ldp   - pointer to load to which resource will be allocated
       mlist - list to hold selected RESMEMB's
     RETURNS:  void
-----------------------------------------------------------------*/
{
     int i, j, *avail;
     double min, *util;
     RESMEMB *minp, *rmp;
     /* Allocate arrays for availability and utilization.  */
     avail = (int *) malloc(sizeof(int) * csszls(gp->rgrsls));
     if ( avail == NULL )
     {
         seferr(0, "Out of Memory");
     }
     util = (double *) malloc(sizeof(double) * csszls(gp->rgrsls));
     if ( util == NULL )
     {
         seferr(0, "Out of Memory");
     }
     /* Compute availability and utilization.  */
     for ( rmp = (RESMEMB *) csfsls(gp->rgrsls), j = 0;
           rmp != NULL;
           rmp = (RESMEMB *) csnxls((CSENTITY *) rmp), j++ )
     {
         avail[j] = seaars(rmp->rmres, ldp);
         util[j] = seutrs(rmp->rmres);
     }
     /* For the required number of units */
     for ( i = csszls(mlist); i &LT nu; i++ )
     {
         /* For each resource which is available.  */
         minp = NULL;
         for ( rmp = (RESMEMB *) csfsls(gp->rgrsls), j = 0;
               rmp != NULL;
               rmp = (RESMEMB *) csnxls((CSENTITY *) rmp), j++ )
         {
             if ( (! rmp->rmres->rsselfg) && (avail[j] > 0) )
             {
               /* Save if min.  */
                 if ( (minp == NULL) || (util[j] &LT min) )
                 {
                     minp = rmp;
                     min = util[j];
                 }
             }
         }
         if ( minp == NULL )
         {
             break;
         }
         seadsl(mlist, minp);
     }
     free(avail);
     free(util);
     return;
}

Installieren der anwenderdefinierten Funktion

Um Ihre anwenderdefinierte Ressourcenzuteilungsfunktion für die Reihenfolgeplanung verfügbar zu machen, müssen Sie sie mit der Funktion ucini1 installieren, indem Sie die Funktion sedfgs aufrufen. Die Funktion sedfgs nimmt zwei Argumente in der folgenden Reihenfolge:

  • Die Nummer der Ressourcenzuteilungsregel, für die Sie das anwenderdefinierte Programm geschrieben haben.
  • Die Adresse der Ressourcenzuteilungsfunktion.

So installieren Sie z.B. die Beispielregel "rgsr" an Regelposition 39: 


sedfgs (39, rgsr);
Verwandte Themen