Écriture de règles d'affectation de ressources personnalisées

Les règles d'affectation de ressources sont utilisées pour décider quelles ressources d'un groupe de ressources seront utilisées par l'ordonnancement lorsque celui-ci affectera les ressources à une charge. Elles sont également utilisées pour la réaffectation de ressources si la réaffectation a été activée pour le groupe.

Remarque : Pour consulter un récapitulatif de la procédure de création des règles personnalisées, reportez-vous à la rubrique Ecriture de règles d'ordonnancement personnalisées. Pour obtenir plus de détails sur les fonctions décrites dans cette rubrique, reportez-vous au Guide de personnalisation de l'ordonnancement (Scheduling Customization Guide) qui peut être téléchargé sur notre site Web d'assistance technique.

Nom de la fonction

La fonction peut porter n'importe quel nom qui n'est pas un nom de fonction standard exécutable par l'utilisateur.

Arguments


#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.    */

La fonction doit accepter quatre arguments dans l'ordre suivant :

Un pointeur vers un groupe de ressources (type : RESGRP*).
Un entier correspondant au nombre de ressources à sélectionner dans ce groupe en vue d'une répartition (type : int).
Un pointeur vers la charge nécessitant une affectation à partir du groupe de ressources (type : LOAD*).
Une liste à renseigner avec RMTAGS de ressources sélectionnées pour affectation à partir du groupe (type : CSLIST*).

Ajout et suppression de membres du groupe

Des membres du groupe peuvent être ajoutés et supprimés de la liste des ressources sélectionnées (mlist) respectivement par les fonctions système seadsl et sermsl. Pour ajouter des membres à une liste, utilisez la fonction seadsl comme suit :


void seadsl(CSLIST *mlist, RESMEMB *rmp)

Pour supprimer des membres d'une liste, utilisez la fonction sermsl comme suit :


void sermsl(CSLIST *mlist, RMTAG *rmt)

Valeurs de retour

La fonction ne doit rien retourner (type : void).

Voici un exemple de règle de sélection des membres du groupe de ressources disponibles sur la base de la moindre utilisation moyenne :


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

Installation de la fonction personnalisée

Pour rendre votre fonction d'affectation de ressources personnalisée disponible pour l'ordonnancement, vous devez l'"installer" à partir de la fonction ucini1 en appelant la fonction sedfgs. La fonction sedfgs a deux arguments dans l'ordre suivant :

Le numéro de la règle d'affectation des ressources pour laquelle votre fonction contient une logique personnalisée.
L'adresse de votre fonction d'affectation des ressources.

Par exemple, pour installer la règle exemple "rgsr" ci-dessus dans la position de règle 39 :


sedfgs (39, rgsr);