Soluções para o problema da Montanha Russa

A mais completa é a primeira onde se verifica, com quatro variáveis de
condição se os passageiros realmente sairam do carrinho.
Para melhorar, apenas daria para reaproveitar a variavel de condição carrinho.

As outras soluções tem pequenos problemas

Todos os comentários são meus (alunos do 4 ano BCC não colocam comentários
nos programas :)

***************************************************************************
Pedro, Fernando, Flávia, Marcos, Stefan e Rodrigo


monitor RollerCoaster {
  cond entrada_liberada, saida_liberada, carrinho_cheio, carrinho_vazio;
  boolean carrinho_OK;   // acho que tem que começar com false - Alfredo
  int capacidade = C;
  count lugares_livres = 0;

  procedure takeRide() {
    if (!empty(entrada_liberada) || carrinho_OK == false)
       wait(entrada_liberada);
    lugares_livres--;
    if (lugares_livres == 0){
       carrinho_OK = false;
       signal(carrinho_cheio)
    }
    else
       signal(entrada_liberada);
    wait(saida_liberada);
    lugares_livres++;
    if (lugares_livres == capacidade)
       signal(carrinho_vazio);
  }
  
  procedure load() {
    lugares_livres = capacidade;
    carrinho_OK = true;
    signal(entrada_liberada);
    wait(carrinho_cheio);
  }

  procedure unload() {
    signal_all(saida_liberada);
    wait(carrinho_vazio);
  }
}

***************************************************************************

Danilo, Fábio, Alex, Cléber, Luiza e Fernando

1)
monitor RoalerCoaster {
  int c, np;    // np começa com c - Alfredo
  cond partir, parado, acabou;
  
  procedure void takeRide() {
    if (!empty(parado) || np == c)
       wait(parado);
    np++;
    if (np < c)
       signal(parado);
    else
       signal(partir);
    wait(acabou);
  }

  procedure void load() {  // colocar o np = 0 e o signal(parado) no load, não
			   // no unload - caso contrário o carrinho pode
			   // começar a encher antes de dar load 
    wait(partir);
  }

  procedure void unload() {
    np = 0;
    signallAll(acabou);
    signal(parado);
  }

2) como acima, mas com uma variável de condição a mais 
  cond ordemChegada;


// parece que funciona :)
  procedure void load(int carId) {
    if (np == c) { np = 0; signal(parado);}
    wait(partir);
    fila.put(carId);
  }

  procedure void unload(int carId) {
    while(fila.primeiro != carId){
      wait(ordemChegada);
    }
    fila.removeFirst();
    signalAll(ordemChegada);
    for(int i = 0; i < c; i++)
       signal(acabou);
  }


***************************************************************************
Alexandre, Andrew, Daniel, Fabio, Keith, Marcos, Vanderlei, Yang e Wu

monitor MRussa {
  int np = 0;  // o np deveria começar com C e o load deveria mudá-lo para 0
  cond fila, carro, volta;

  procedure takeRide {
     while (np == C)
       wait(fila);
     if (np == c - 1)
       signal(carro);
     np++;
     wait(volta);
  }

  procedure load {
     if (np < c)  // se você coloca np = 0 aqui basta fazer o wait (sem o if)
       wait(carro);
  }

  procedure unload {
     np = 0;      //este comando vai para o load e sai daqui
     signal_all(volta);
     signal_all(fila); // prefiro a solução onde você acorda o primeiro e ele
		       // cuida de acordar o próximo e assim por diante. Este
		       // também vai para o load
  }

***************************************************************************

Daniel x2, Igor, Peter, Lenadro e Giuliano

1)
#define C 17

monitor Roller {
  int numPass = 0;
  int esperando = 0;  
  cond podeEntrar, podeZarpar, fimPasseio;

  takeRide() {
    if (numPass == C) {
       esperando++;
       wait(podeEntrar);
    } else {
       numPass++;
       signal(podeZarpar);  // aqui você deixa o carrinho partir mesmo
			    // incompleto ?
    }
    wait(fimPasseio);
  }

  load() {
    if (numPass < C)        // novamente, eu colocaria numPass = 0 no load()
      wait(podeZarpar);
  }

  unload() {
    int i;
    numPass = 0;
    if (esperando > 0) {
       numPass = esperando > C ? C : esperando;
       esperando -= numPass;
       for (i = 0; i < numPass; i++)
         signal(podeEntrar);  // se você dá o signal aqui passageiros podem
			      // entrar mesmo antes da chamada a load()
    }
    signalAll(fimPasseio); 
  }
}

2)
 monitor Roller {
    int ultimo = 0, proximo = 1;
    cond varzea;

    // takeRide = ao de cima

    int load() {
      if (numPass < C) wait(podeZarpar);
      ultimo++;
      return ultimo;
    }

    void unload(i) {
      while (i != proximo) wait(varzea);
      proximo++;
      signalAll(varzea);
      // o resto é igual ao de cima [cometário do grupo]
      // agora o meu, tem que melhorar um pouco pois não dá
      // para fazer o signalAll mais
    }
  }