Verfassen von anwenderdefinierten Auswahlregeln
Auswahlregellogik
Bevor Sie anwenderdefinierte Auswahlregeln erstellen und die entsprechenden Auswahlfunktionen schreiben können, müssen Sie die von der Auswahlfunktion verwendete Logik verstanden haben. Wenn eine Ressource verfügbar wird, wird die Auswahlfunktion aufgerufen. Die Anforderungswarteschlangen sind in internen Listen enthalten, deren jeweiliger Besitzer die Ressource ist, die von der Reihenfolgeregel als erste eingeordnet wurde.
Wenn die Auswahlfunktion aufgerufen wird, sortiert sie die Liste neu und gibt die maximale Anzahl von Anforderungen, die beim Zuteilungsprozess berücksichtigt werden sollen, zurück. Wenn die gesamte Liste sortiert ist, wird die Größe der Liste zurückgegeben. Ist die Anzahl der zurückgegebenen Anforderungen geringer als die Größe der Liste, stellt die sortierte Liste für die Zuteilung möglicherweise nur einen Teil der Anforderungswarteschlange dar.
Der Zuteilungsprozess beginnt mit dem Versuch, den Arbeitsgang für die erste Anforderung der sortierten Liste, der die verfügbare Anzahl von Einheiten oder weniger erfordert, neu zu starten. Wenn der Zuteilungsprozess fehlschlägt, wird die nächste Anforderung der sortierten Liste mit der Anzahl der verfügbaren Einheiten oder weniger verglichen. Aufeinanderfolgende Anforderungen der sortierten Liste für die Zuteilung werden so lange geprüft, bis die verfügbaren Einheiten zugeteilt wurden oder bis das Ende der Liste erreicht ist. Sind verfügbare Einheiten nach Prüfung der letzten Anforderung vorhanden, bleiben sie unproduktiv.
Benennen der Funktion
Sie können einen beliebigen Namen für Ihre anwenderdefinierte Auswahlfunktion wählen, solange es sich nicht um den Namen einer von Anwendern aufrufbaren Standardfunktion handelt.
Argumente
#include "factor.h"
int myrule(rp)
RESRC *rp; /* pointer to the resource */Die Auswahlfunktion akzeptiert als einziges Argument einen Zeiger auf die Komponente, für die Sie die Auswahl vornehmen. Es handelt sich dabei um eine Ressource (Typ: RESRC *).
Rückgabewert
Die Funktion gibt einen Wert aus (Typ: int), der der maximalen Anzahl der zu verarbeitenden Anforderungen entspricht.
Im Folgenden ist ein Beispiel für eine Ressourcenauswahlfunktion angegeben, die auf der Mindestrüstzeit basiert:
int slrl (RESRC *rp)
/*-----------------------------------------------------------------
Selection function to process a resource request list by using
the minimum setup time for this resource on the first downstream
setup operation for each load. Loads that have no downstream setup
operation are assumed to have a setup time of zero.
NOTES:
* The estimate flag is set to false for jscmsu so that it will
use the current conditions to find the setup time. Since the
operation could be downstream, there is no guarantee that the
current conditions for the resource in question will still
be appropriate when the setup actually occurs. Therefore,
this rule should only be used when the structure of the model
guarantees that the conditions for the downstream resource
will be constant till the setup occurs.
ARGS:
rp - pointer to resource to resequence
RETURNS: number of requests in the request list
-----------------------------------------------------------------*/
{
RREQ *rq;
JOBSTEP *jsp;
int i;
for ( rq = (RREQ *) csfsls(rp->rsrqls);
rq != NULL;
rq = (RREQ *) csnxls((CSENTITY *) rq) )
{
/* Find first downstream setup operation. */
for ( jsp = rq->rrload->lojspt, i = 0;
jsp != NULL && jsp->jstype != 4 &&
jsp->jstype != 13 && jsp-jstype != 19 && i < 1000;
jsp = jsp->jspnxt, i++);
/* Compute setup time (zero if no setup operation). */
if (jsp == NULL || i >= 1000)
{
rq->rrprio = 0.0;
}
else
{
/* Place a tag for the resource. This allows the step
time to be computed properly for the downstream
operation assuming that the load allocates the
resource before any other load. */
dumrtag->rtrsrc = rp;
cspols(rq->rrload->lorsls, (CSENTITY *) dumrtag, CSLIFO, NULL);
rq->rrprio = jscmsu(0, rq->rrload, jsp);
csgpls(rq->rrload->lorsls, (CSENTITY *) dumrtag);
}
}
/*Sort list based on rankings.*/
cssols (rp->rsrqls, serqor);
/*return number in list*/
return (csszls(rp->rsrqls));
}Installieren der anwenderdefinierten Funktion
Um Ihre anwenderdefinierte Ressourcenauswahlfunktion für die Reihenfolgeplanung verfügbar zu machen, müssen Sie sie mit der Funktion ucini1 installieren, indem Sie die Funktion sedfsl aufrufen. Diese Funktion hat zwei Argumente in der folgenden Reihenfolge:
- Die Nummer der Auswahlregel, für die Sie das anwenderdefinierte Programm geschrieben haben.
- Die Adresse der Auswahlfunktion.
So installieren Sie die Beispielregel "slrl" an Regelposition 39:
sedfsl (39, slrl);Wenn Sie eine der integrierten "dynamischen" Auswahlregeln verwenden, ignoriert das System die Reihenfolgeregel und geht nach dem FIFO-Prinzip (First In, First Out) vor. Wenn Sie eine dynamische Auswahlregel schreiben, sollten Sie diesem Beispiel folgen und ebenfalls die Anwendung des FIFO-Prinzips erzwingen. In diesem Fall müssen Sie die Funktion setosq für die zutreffende Anforderungsliste aufrufen.