- - - - CENAPAD-MGCO

A seguir: 4a. Questão Acima: Marcelo Bernardes Vieira Anterior: 2a. Questão

3a. Questão

Considerações iniciais:

• A solução é dada pela modificação constante da fila de prioridades.
• Um escritor só escreve se não houver processos. Ao terminar a escrita a função ReleaseWrite usa a função wainting.PROMOTEREAD() que coloca todos os processos leitores no topo da fila em ordem de chegada. A variável FLUSHREAD recebe o número de leitores que deverão ser liberados.
• Se um processo escritor entrar na fila de prioridades quando os processos leitores de devem ser liberados ainda não forem liberados (FLUSREAD > 0), então este entra no fim da fila.
• Se somente existir processos leitores, mas FLUSHREAD == 0 indicando que os processos leitores não DEVEM ser liberados, então RequestWrite executa a função waiting.PROMOTEWRITE() que promove todos os processos escritores para o inicio da fila. (Um leitor não pode ler se houver processos escritores na fila).
• Não há possibilidade de starvation porque as constantes modificações na fila de prioridades mantêm a ordem de chegada de escritores e leitores separadamente.

a) Programa cliente:

        void escritor() {                       void Leitor() {
                RequestWrite();                         RequestRead();
                ...                                     ...
                ReleseWrite();                          ReleseRead();
        }                                       }

b) Controlador leitor/escritor:

        key     mutex;   RWQueue waiting;   Bed b;
        int     nw = 0,  nr = 0, flushread = 0;

        void RequestWrite() {
             lock(mutex);
                int myticket = waiting.GetTicket(WRITE);

                if(flushread == 0) waiting.PromoteWrite();

                while( !waiting.IsTheBest(myTicket) || nw > 0 || nr > 0) {
                        wait(b, mutex);
                }
                nw++;
                waiting.ok(myticket);
                unlock(mutex);
             unlock(mutex);
        }

        void RequestRead() {
             lock(mutex);
                int myticket = waiting.GetTicket(READ);
                while(!waiting.IsTheBest(myticket) || nw > 0) {
                        wait(b, mutex);
                }
                if(flushread > 0) flushread--;
                nr++;
                waiting.Ok(myticket);
                wakeup(b, mutex);
             unlock(mutex);
        }

        void ReleaseWrite() {
             lock(mutex);
                flushread = waiting.PromoteRead();
                nw--;
                wakeup(b, mutex);
             unlock(mutex);
        }

        void ReleaseRead() {
             lock(mutex);
                nr--;
                wakeup(b, mutex);
             unlock(mutex);
        }

c) Fila de prioridades:

        int ticket = 0;     Queue q;

        int GetTicket(int tipo) {
                q.Put(++ticket, tipo);
                return( ticket );
        }

        boolean IsTheBest(int ticket) {
                return( q.top == NULL || q.top == ticket);
        }
        
        void Ok(int ticket) {
                q.Del(ticket);
        }

        int PromoteRead() {
                // Coloca todos os processos de leitura no topo
                // obedecendo a ordem de chegada e retornando
                // o n\'{u}mero de leitores que est\~{a}o no topo
        }

        int PromoteWrite() {
                // Coloca todos os processos de escrita no topo
                // obedecendo a ordem de chegada
        }