Threads

[hallowelt543]

Je Prozessor gibt es 3 Thread-Warteschlangen: eine sogenannte Realtime-Warteschlange struct runq tdq_realtime, eine sogenannte Timesharing-Warteschlange struct runq tdq_timeshare und eine Leerlauf Warteschlange truct runq tdq_idle. Wenn ein neuer Thread ausgeführt werden soll, wird letztendlich die folgende Methode aufgerufen:

/*
* Pick the highest priority task we have and return it.
*/
static struct thread *
tdq_choose(struct tdq *tdq)
{
struct thread *td;
TDQ_LOCK_ASSERT(tdq, MA_OWNED);
td = runq_choose(&tdq->tdq_realtime);
if (td != NULL)
         return (td);
td = runq_choose_from(&tdq->tdq_timeshare, tdq->tdq_ridx);
if (td != NULL) {
        KASSERT(td->td_priority >= PRI_MIN_BATCH,
             ("tdq_choose: Invalid priority on timeshare
              queue %d", td->td_priority));
        return (td);
}
td = runq_choose(&tdq->tdq_idle);
if (td != NULL) {
        KASSERT(td->td_priority >= PRI_MIN_IDLE,
        ("tdq_choose: Invalid priority on idle queue %d",
           td->td_priority));
      return (td);
}
      return (NULL);
}

Die Methoden runq_choose() und runq_choose_from() geben jeweils einen Thread aus der übergebenen Warteschlange zurück. Begründen Sie anhand des gegebenen Codeausschnitts, ob Fairness zwischen Threads in verschiedenen lokalen Warteschlangen besteht. D.h. begründen Sie, ob sichergestellt ist, dass, vorausgesetzt alle drei Warteschlangen enthalten ausführbereite Threads, letztendlich aus jeder Warteschlange ein Thread ausgewählt wird, wenn keinerlei weitere Annahmen über den Einreihevorgang in die Warteschlangen getroffen werden.

Meine Überlegung:
Da die Realtime-Warteschlange zuerst ausgeführt, daraufhin die Timesharing-Warteschlange und zuletzt die Leerlauf-Warteschlange abgearbeitet wird. Da diese Reihenfolge existiert, kann keine Fairness existieren.

Habt ihr bessere Begründungen??
Danke im Voraus

 

[mihe7]

Die Überlegung ist im Prinzip nicht falsch, orientiert sich vermutlich aber zu wenig am Code. D. h. ich würde die Begründung anders formulieren: unter der Voraussetzung X wird aufgrund von Y immer der Thread aus der Z-Warteschlange ausgewählt. D.h. ... fertig.