Exemple #1
0
        /// <summary>
        /// Método responsável por verificar se intervalo está contido na lista de semáforos com intervalos já existentes.
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <param name="semaforos">Lista de Semáforos já existentes</param>
        /// <returns>Confirmação se irá ou não impactar</returns>
        public static bool RnVerificarIntervaloImpactara(short inicio, short final, List <SemaforoPorIntervalo> semaforos)
        {
            SemaforoPorIntervalo semaforo = null;

            if (semaforos.Count > 0)
            {
                semaforo = semaforos.Where(o => inicio >= o.inicio && inicio <= o.final).FirstOrDefault();

                if (semaforo != null)
                {
                    return(true);
                }

                semaforo = semaforos.Where(o => final >= o.inicio && final <= o.final).FirstOrDefault();

                if (semaforo != null)
                {
                    return(true);
                }

                semaforo = semaforos.Where(o => inicio <= o.inicio && final >= o.final).FirstOrDefault();

                if (semaforo != null)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }

            return(false);
        }
Exemple #2
0
        /// <summary>
        /// Método responsável por verificar se intervalo está contido no semáforo com intervalo já existente.
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <param name="semaforo">Semáforo já existente</param>
        /// <returns>Confirmação se irá ou não impactar</returns>
        public static bool RnVerificarIntervaloImpactara(short inicio, short final, SemaforoPorIntervalo semaforo)
        {
            if (semaforo != null)
            {
                if (inicio >= semaforo.inicio && inicio <= semaforo.final)
                {
                    return(true);
                }

                if (final >= semaforo.inicio && final <= semaforo.final)
                {
                    return(true);
                }

                if (inicio <= semaforo.inicio && final >= semaforo.final)
                {
                    return(true);
                }
                if (inicio >= semaforo.inicio && final <= semaforo.inicio)
                {
                    return(true);
                }
                else
                {
                    return(false);
                }
            }
            return(false);
        }
Exemple #3
0
 /// <summary>
 /// Método responsável por liberar os semáforos a partir do índice atual dos semáforos.
 /// </summary>
 /// <param name="semaforosPorIntervalo">Lista de semáforos</param>
 /// <param name="indice">Indice da posicao do semáforo</param>
 public static void LiberarSemaforo(List <SemaforoPorIntervalo> semaforosPorIntervalo, int indice)
 {
     for (int i = indice; i < semaforosPorIntervalo.Count; i++)
     {
         SemaforoPorIntervalo.LiberarSemaforo(semaforosPorIntervalo[i]);
     }
 }
Exemple #4
0
        /// <summary>
        /// Método responsável por validar a necessidade de criar novos semáforos de acordo com os novos intervalos,
        /// ou se apenas deve-se reaproveitar o semáforo existentes.
        /// </summary>
        /// <param name="semaforoPorIntervalo">Semáforo que deseja comparar para verificar se há necessidade de criar novos semáforos</param>
        /// <param name="inicio">ponto mínimo do intervalo atual</param>
        /// <param name="final">ponto máximo do intervalo atual</param>
        /// <returns>Lista de semáforos que se deve esperar</returns>
        public static void VerificarSemaforosImpactados(ref List <SemaforoPorIntervalo> semaforosImpactadosAguardar,
                                                        ref List <SemaforoPorIntervalo> semaforosImpactadosNovos,
                                                        ref List <SemaforoPorIntervalo> semaforosExistentes,
                                                        SemaforoPorIntervalo semaforoPorIntervalo, short inicio, short final)
        {
            if (!(inicio <= final))
            {
                return;
            }

            //Verifica se o intervalo está contido no intervalo em verificação atual.
            if (RnVerificarInicioFinalIntervaloEstaContidoEmOutroIntervalo(inicio, final, semaforoPorIntervalo))
            {
                if (RnValidarAdicionarSemaforoParaAguarde(semaforosImpactadosAguardar, semaforosImpactadosNovos, semaforoPorIntervalo))
                {
                    SemaforoPorIntervalo.IncrementarContadorSemaforoEmEspera(semaforoPorIntervalo);

                    semaforosImpactadosAguardar.Add(semaforoPorIntervalo);
                }

                return;
            }

            //verifica se intervalo irá impactar no intervalo já existente
            //Se não impactar irá querer criar um novo semáforo.
            if (!(RnVerificarIntervaloImpactara(inicio, final, semaforoPorIntervalo)))
            {
                //Verifica se intervalo não irá impactar nos intervalos já existentes ou nos novos intervalos já existentes
                if (!(RnVerificarIntervaloImpactara(inicio, final, semaforosImpactadosNovos) ||
                      RnVerificarIntervaloImpactara(inicio, final, semaforosImpactadosAguardar) ||
                      RnVerificarIntervaloImpactara(inicio, final, semaforosExistentes)))
                {
                    semaforosImpactadosNovos.Add(new SemaforoPorIntervalo(inicio, final, 1));
                    semaforosExistentes.Add(new SemaforoPorIntervalo(inicio, final, 1));
                }
            }
            //Se impactar vai adicionar o semáforo atual na lista de aguarde
            //e verifica onde irá impactar para realizar as validações para então decidir se irá criar outro semáforo ou não.
            else
            {
                if (RnValidarAdicionarSemaforoParaAguarde(semaforosImpactadosAguardar, semaforosImpactadosNovos, semaforoPorIntervalo))
                {
                    SemaforoPorIntervalo.IncrementarContadorSemaforoEmEspera(semaforoPorIntervalo);

                    semaforosImpactadosAguardar.Add(semaforoPorIntervalo);
                }

                //Verifica se o intervalo incorpora outro intervalo dentro dele (o intervalo que está sendo verificado)
                if (RnVerificarInicioFinalCobremIntervaloAtual(inicio, final, semaforoPorIntervalo))
                {
                    RnConstruirSemaforoQueAbrangeSemaforoAtual(inicio, final, semaforoPorIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
                }
                //Se não quer dizer que ou o início ou final estão impactando em algum semáforo.
                else
                {
                    RnConstruirSemaforoQueAbrangeInicioOuFinalSemaforoAtual(inicio, final, semaforoPorIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
                }
            }
        }
Exemple #5
0
        /// <summary>
        /// Método responsável por atualizar o contador que indica se há um thread esperando em determinado semáforo.
        /// </summary>
        /// <param name="semaforoPorIntervalo">Objeto que contém os dados do semáforo</param>
        public static void DecrementarContadorSemaforoEmEspera(SemaforoPorIntervalo semaforoPorIntervalo)
        {
            semaforoPorIntervalo.semaforoEmEspera.WaitOne();

            semaforoPorIntervalo.emEspera -= 1;

            semaforoPorIntervalo.semaforoEmEspera.Release();
        }
 /// <summary>
 /// Método responsável por excluir os semáforos inutilizados da lista de semáforos existentes.
 /// </summary>
 /// <param name="semaforosParaExcluir">Lista de semáforos que deverão ser excluídos</param>
 /// <param name="semaforosExistentes">Lista de semáforos existentes atualmente</param>
 public static void ExcluirSemaforosInativos(ref List <SemaforoPorIntervalo> semaforosParaExcluir, ref List <SemaforoPorIntervalo> semaforosExistentes)
 {
     //excluindo semáforos da lista de semaforos por cronograma
     for (int i = 0; i < semaforosParaExcluir.Count; i++)
     {
         SemaforoPorIntervalo.DestruirSemaforo(semaforosParaExcluir[i]);
         semaforosExistentes.Remove(semaforosParaExcluir[i]);
     }
 }
Exemple #7
0
 /// <summary>
 /// Método responsável por liberar recursos do semáforo criado que não possua mais ninguém em espera.
 /// </summary>
 /// <param name="semaforoIntervalo">Objeto SemaforoPorIntevalo</param>
 public static void DestruirSemaforo(SemaforoPorIntervalo semaforoIntervalo)
 {
     if (semaforoIntervalo.emEspera == 0)
     {
         semaforoIntervalo.semaforo.Dispose();
         semaforoIntervalo.semaforo = null;
         semaforoIntervalo          = null;
     }
 }
Exemple #8
0
        /// <summary>
        /// Método responsável por verificar se o semaforoPorIntervalo1 é diferente do semaforoPorIntervalo2
        /// </summary>
        /// <param name="semaforoPorIntervalo1">Objeto semáforo 1</param>
        /// <param name="semaforoPorIntervalo2">Objeto semáforo 2</param>
        /// <returns>True (Se forem iguais), False (Se não forem iguais)</returns>
        public static bool VerificarSemaforosSaoIguais(SemaforoPorIntervalo semaforoPorIntervalo1, SemaforoPorIntervalo semaforoPorIntervalo2)
        {
            if (semaforoPorIntervalo1.Oid != semaforoPorIntervalo2.Oid)
            {
                return(false);
            }

            return(true);
        }
Exemple #9
0
 /// <summary>
 /// Método que verifica se o intervalo atual é o mesmo que está sendo comparado, verifica se são iguais.
 /// </summary>
 /// <param name="inicio">Início do intervalo atual</param>
 /// <param name="final">Final do intervalo atual</param>
 /// <param name="semaforoPorIntervalo">Semáforo existente que está sendo comparado no momento</param>
 /// <returns>Confirmação se são ou não iguais</returns>
 public static bool RnValidarIntervalosIguais(short inicio, short final, SemaforoPorIntervalo semaforoPorIntervalo)
 {
     if (inicio == semaforoPorIntervalo.inicio && final == semaforoPorIntervalo.final)
     {
         return(true);
     }
     else
     {
         return(false);
     }
 }
Exemple #10
0
        /// <summary>
        /// Método responsável por verificar se final do intervalo está contido no semáforo atual.
        /// </summary>
        /// <param name="final">Final do intervalo</param>
        /// <param name="semaforo">Semáforo já existente</param>
        /// <returns>Confirmação se está ou não contido</returns>
        public static bool RnVerificarFinalEstaContido(short final, SemaforoPorIntervalo semaforo)
        {
            if (semaforo != null)
            {
                if (final >= semaforo.inicio && final <= semaforo.final)
                {
                    return(true);
                }
            }

            return(false);
        }
Exemple #11
0
        /// <summary>
        /// Método responsável por verificar se início do intervalo está contido no semáforo atual.
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="semaforo">Semáforo já existente</param>
        /// <returns>Confirmação se está ou não contido</returns>
        public static bool RnVerificarInicioEstaContido(short inicio, SemaforoPorIntervalo semaforo)
        {
            if (semaforo != null)
            {
                if (inicio >= semaforo.inicio && inicio <= semaforo.final)
                {
                    return(true);
                }
            }

            return(false);
        }
Exemple #12
0
        /// <summary>
        /// Método responsável por gerar um intervalo
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <returns></returns>
        public static List <short> CriarIntervalo(short inicio, short final)
        {
            List <short> novoIntervalo = new List <short>();

            SemaforoPorIntervalo.ValidarParametrosCriarIntervalo(ref inicio, ref final);

            int contador = final - inicio;

            for (int i = 0; i <= contador; i++)
            {
                novoIntervalo.Add(inicio);
                inicio++;
            }

            return(novoIntervalo);
        }
Exemple #13
0
        /// <summary>
        /// Método responsável por verificar se final do intervalo está contido na lista de semáforos já existentes.
        /// </summary>
        /// <param name="final">Final do intervalo</param>
        /// <param name="semaforos">Semáforos já existentes</param>
        /// <returns>Confirmação se está ou não contido</returns>
        public static bool RnVerificarFinalEstaContido(short final, List <SemaforoPorIntervalo> semaforos)
        {
            SemaforoPorIntervalo semaforo = null;

            if (semaforos.Count > 0)
            {
                semaforo = semaforos.Where(o => final >= o.inicio && final <= o.final).FirstOrDefault();

                if (semaforo != null)
                {
                    return(true);
                }
            }

            return(false);
        }
Exemple #14
0
        /// <summary>
        /// Método que verifica se um intervalo pode ser adicionado na lista de aguarde ou não.
        /// Caso ele não exista em nenhuma lista, então poderá adicionar.
        /// </summary>
        /// <param name="inicio">Início do intervalo atual</param>
        /// <param name="final">Final do intervalo atual</param>
        /// <param name="semaforosImpactadosAguardar">Lista de semáforos que irá aguardar</param>
        /// <param name="semaforosImpactadosNovos">Lista de semáforos que irá criar</param>
        /// <param name="semaforoPorIntervalo">Semáforo existente que está sendo comparado no momento</param>
        /// <returns>Confirmação se pode adicionar ou não o semáforo na lista de aguarde</returns>
        public static bool RnValidarAdicionarSemaforoParaAguarde(List <SemaforoPorIntervalo> semaforosImpactadosAguardar,
                                                                 List <SemaforoPorIntervalo> semaforosImpactadosNovos,
                                                                 SemaforoPorIntervalo semaforoPorIntervalo)
        {
            bool adicionar;

            if (!RnValidarSemaforosIguaisPorLista(semaforosImpactadosAguardar, semaforosImpactadosNovos, semaforoPorIntervalo))
            {
                adicionar = true;
            }
            else
            {
                adicionar = false;
            }

            return(adicionar);
        }
Exemple #15
0
        /// <summary>
        /// Método que verifica se o intervalo atual se já está adicionado em alguma lista de aguarde ou de novos semáforos para criar.
        /// </summary>
        /// <param name="semaforosImpactadosAguardar">Lista de semáforos que irá aguardar</param>
        /// <param name="semaforosImpactadosNovos">Lista de semáforos que irá criar</param>
        /// <param name="semaforoPorIntervalo">Intervalo que está sendo verificado</param>
        /// <returns>Confirmação se já está adicionado ou não.</returns>
        public static bool RnValidarSemaforosIguaisPorLista(List <SemaforoPorIntervalo> semaforosImpactadosAguardar,
                                                            List <SemaforoPorIntervalo> semaforosImpactadosNovos,
                                                            SemaforoPorIntervalo semaforoPorIntervalo)
        {
            bool adicionado;

            SemaforoPorIntervalo semaforoExistente = semaforosImpactadosAguardar.Where(o => semaforoPorIntervalo.inicio == o.inicio && semaforoPorIntervalo.final == o.final).FirstOrDefault();
            SemaforoPorIntervalo semaforoNovo      = semaforosImpactadosNovos.Where(o => semaforoPorIntervalo.inicio == o.inicio && semaforoPorIntervalo.final == o.final).FirstOrDefault();

            if (semaforoExistente == null && semaforoNovo == null)
            {
                adicionado = false;
            }
            else
            {
                adicionado = true;
            }

            return(adicionado);
        }
        /// <summary>
        /// Método responsável controlar o acesso de threads simultaneamente enquanto leem e escrevem tanto no dicionário de cronogramas quanto na lista de semáforos de cada cronograma.
        /// Valida o acesso por cronograma e intervalo.
        /// </summary>
        /// <param name="oidCronograma">Oid cronograma</param>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        public virtual Hashtable ControlarSemaforos(Guid oidCronograma, short inicio, short final)
        {
            Hashtable semaforos = new Hashtable();

            ControlarIncrementacaoContadorAcessoPorCronograma(oidCronograma);

            ControlarExclusaoSemaforosInativosPorCronograma(oidCronograma);

            if (ValidarCronograma(oidCronograma))
            {
                semaforos = ConsultarSemaforosImpactadosPorCronograma(oidCronograma, inicio, final, semaforos);

                ControlarExclusaoCronogramasInexistentes();
            }
            else
            {
                EsperarEscritaCronogramas();

                if (semaforosPorCronograma.ContainsKey(oidCronograma))
                {
                    LiberarEscritaCronogramas();

                    semaforos = ConsultarSemaforosImpactadosPorCronograma(oidCronograma, inicio, final, semaforos);

                    ControlarExclusaoCronogramasInexistentes();

                    ControlarDecrementacaoContadorAcessoPorCronograma(oidCronograma);

                    return(semaforos);
                }
                else
                {
                    //cria um objeto SemaforoPorCronograma que armazena um semáforo e a lista de semáforos de um cronograma
                    SemaforosControle semaforosControle = new SemaforosControle()
                    {
                        lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
                    };

                    //cria um semáforo
                    SemaforoPorIntervalo novoSemaforo = new SemaforoPorIntervalo(inicio, final);

                    //cria uma lista para retornar na Hash
                    List <SemaforoPorIntervalo> semaforosNovos = new List <SemaforoPorIntervalo>();

                    semaforosNovos.Add(novoSemaforo);

                    //Adiciona o semáforo novo criado para retornar na hash
                    semaforos.Add(SEMAFOROS_NOVOS, semaforosNovos);

                    //adiciona o semáforo à lista de semáforo por cronograma.
                    semaforosControle.semaforos.Add(novoSemaforo);

                    //adiciona o cronograma e sua lista ao dicionário de cronogramas ativos.
                    semaforosPorCronograma.Add(oidCronograma, semaforosControle);
                }

                ControlarExclusaoCronogramasInexistentes();

                LiberarEscritaCronogramas();
            }

            ControlarDecrementacaoContadorAcessoPorCronograma(oidCronograma);

            return(semaforos);
        }
Exemple #17
0
 /// <summary>
 /// Método responsável por Liberar um semáforo e decrementar o contador, que indica se um semáforo está em espera, dos demais semáforos da lista que seria usada.
 /// </summary>
 /// <param name="semaforoPorIntervalo">Semáforo para liberar</param>
 /// <param name="semaforosPorIntervalo">Lista de semáforos para decrementar o contador em espera</param>
 /// <param name="indice">índice em que a lista irá começar a decrementar</param>
 public static void LiberarSemaforoEDecrementarContadoresEmEsperaDosDemaisSemaforos(SemaforoPorIntervalo semaforoPorIntervalo, List <SemaforoPorIntervalo> semaforosPorIntervalo, int indice = 0)
 {
     SemaforoPorIntervalo.LiberarSemaforo(semaforoPorIntervalo);
     SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforosPorIntervalo, indice);
 }
Exemple #18
0
 /// <summary>
 /// Método responsável por liberar um semáforo que está em espera e diminuir o atributo que indicar que ele está em espera.
 /// </summary>
 /// <param name="semaforoPorIntervalo">Semáforo para ser liberado</param>
 public static void LiberarSemaforoEDecrementarContadorSemaforoEmEspera(SemaforoPorIntervalo semaforoPorIntervalo)
 {
     SemaforoPorIntervalo.LiberarSemaforo(semaforoPorIntervalo);
     SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforoPorIntervalo);
 }
Exemple #19
0
        /// <summary>
        /// Método responsável por analisar a possibilidade de construir um semáforo e construí-lo quando início ou final de um intervalo não estiverem incorporados em outro.
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <param name="semaforoPorIntervalo">Semáforo atual</param>
        /// <param name="semaforosExistentes">Lista de semáforos existentes</param>
        /// <param name="semaforosImpactadosNovos">Lista de semáforos criados recentemente</param>
        public static void RnConstruirSemaforoQueAbrangeInicioOuFinalSemaforoAtual(short inicio, short final, SemaforoPorIntervalo semaforoPorIntervalo,
                                                                                   ref List <SemaforoPorIntervalo> semaforosExistentes,
                                                                                   ref List <SemaforoPorIntervalo> semaforosImpactadosNovos)
        {
            //Verifica se o início está contido no semáforo em comparação, mas o final não está.
            if (RnVerificarInicioEstaContido(inicio, semaforoPorIntervalo) && final > semaforoPorIntervalo.final)
            {
                int novoInicioIntervalo = semaforoPorIntervalo.final + 1;

                List <short> novoIntervalo = CriarIntervalo(short.Parse(novoInicioIntervalo.ToString()), final);

                RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
            }
            //Verifica se o final está contido no semáforo em comparação, mas o início não está.
            else if (inicio < semaforoPorIntervalo.inicio && RnVerificarFinalEstaContido(final, semaforoPorIntervalo))
            {
                int novoFinalIntervalo = semaforoPorIntervalo.inicio - 1;

                List <short> novoIntervalo = CriarIntervalo(inicio, short.Parse(novoFinalIntervalo.ToString()));

                RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
            }
        }
Exemple #20
0
        /// <summary>
        /// Verificar se um determinado intervalo incorpora outro intervalo, mas ainda contém pontos do intervalo não abrangidos.
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <param name="SemaforoPorIntervalo">semáforo para validar</param>
        /// <returns>Confirmação se está ou não contido</returns>
        public static bool RnVerificarInicioFinalCobremIntervaloAtual(short inicio, short final, SemaforoPorIntervalo semaforo)
        {
            if (semaforo != null)
            {
                if (inicio < semaforo.inicio && final > semaforo.final)
                {
                    return(true);
                }
            }

            return(false);
        }
        /// <summary>
        /// Método responsável por consultar os semáforos que uma determinada thread de reordenação deverá esperar para então executar sua própria reordenação.
        /// </summary>
        /// <param name="oidCronograma">Oid do cronograma (índice do dicionário de cronogramas)</param>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <returns>Retorna uma lista contendo os semáforos que deve-se esperar</returns>
        public Hashtable ConsultarSemaforosImpactadosPorCronograma(Guid oidCronograma, short inicio, short final, Hashtable semaforos)
        {
            List <SemaforoPorIntervalo> semaforosImpactadosAguardar = new List <SemaforoPorIntervalo>();
            List <SemaforoPorIntervalo> semaforosImpactadosNovos    = new List <SemaforoPorIntervalo>();

            lock (semaforosPorCronograma[oidCronograma].semaforos)
            {
                EsperarLeituraSemaforos(oidCronograma);

                if (semaforosPorCronograma[oidCronograma].semaforos.Count == 0)
                {
                    semaforosImpactadosNovos.Add(new SemaforoPorIntervalo(inicio, final));
                }
                else
                {
                    for (int i = 0; i < semaforosPorCronograma[oidCronograma].semaforos.Count; i++)
                    {
                        SemaforoPorIntervalo.VerificarSemaforosImpactados(ref semaforosImpactadosAguardar, ref semaforosImpactadosNovos, ref semaforosImpactadosNovos,
                                                                          semaforosPorCronograma[oidCronograma].semaforos[i], inicio, final);

                        if (semaforosImpactadosNovos.Count > 0)
                        {
                            if (semaforosImpactadosAguardar.Count > 0)
                            {
                                for (int indice = 0; indice < semaforosImpactadosAguardar.Count; indice++)
                                {
                                    SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforosImpactadosAguardar[indice]);
                                }
                            }
                            break;
                        }
                    }
                }

                LiberarLeituraSemaforos(oidCronograma);

                if (semaforosImpactadosNovos.Count > 0)
                {
                    EsperarEscritaSemaforos(oidCronograma);

                    semaforosImpactadosAguardar.Clear();
                    semaforosImpactadosNovos.Clear();

                    List <SemaforoPorIntervalo> semaforosExistentes = semaforosPorCronograma[oidCronograma].semaforos;

                    if (semaforosPorCronograma[oidCronograma].semaforos.Count == 0)
                    {
                        SemaforoPorIntervalo novoSemaforo = new SemaforoPorIntervalo(inicio, final);

                        semaforosPorCronograma[oidCronograma].semaforos.Add(novoSemaforo);

                        semaforosImpactadosNovos.Add(novoSemaforo);
                    }
                    else
                    {
                        for (int i = 0; i < semaforosPorCronograma[oidCronograma].semaforos.Count; i++)
                        {
                            if (semaforosPorCronograma[oidCronograma].semaforos[i].semaforo != null)
                            {
                                SemaforoPorIntervalo.IncrementarContadorSemaforoEmEspera(semaforosPorCronograma[oidCronograma].semaforos[i]);

                                SemaforoPorIntervalo.VerificarSemaforosImpactados(ref semaforosImpactadosAguardar, ref semaforosImpactadosNovos, ref semaforosExistentes,
                                                                                  semaforosPorCronograma[oidCronograma].semaforos[i], inicio, final);

                                SemaforoPorIntervalo.DecrementarContadorSemaforoEmEspera(semaforosPorCronograma[oidCronograma].semaforos[i]);
                            }
                            else
                            {
                                semaforosPorCronograma[oidCronograma] = new SemaforosControle()
                                {
                                    lockerSemaforos = new ReaderWriterLockSlim(), semaforos = new List <SemaforoPorIntervalo>()
                                };

                                //cria um semáforo
                                SemaforoPorIntervalo novoSemaforo = new SemaforoPorIntervalo(inicio, final);

                                semaforosImpactadosNovos.Add(novoSemaforo);

                                semaforosPorCronograma[oidCronograma].semaforos.Add(novoSemaforo);
                            }
                        }
                    }

                    LiberarEscritaSemaforos(oidCronograma);
                }
            }

            semaforos.Add(SEMAFOROS_AGUARDAR, semaforosImpactadosAguardar);
            semaforos.Add(SEMAFOROS_NOVOS, semaforosImpactadosNovos);

            return(semaforos);
        }
Exemple #22
0
 /// <summary>
 /// Método responsável por liberar o semáforo.
 /// </summary>
 /// <param name="semaforo">Semáforo que deseja efeturar a liberação (release)</param>
 /// <param name="posicoesLiberadas">Quantidade de posições que serão liberadas no semáforo</param>
 public static void LiberarSemaforo(SemaforoPorIntervalo semaforoPorIntervalo)
 {
     semaforoPorIntervalo.semaforo.Release();
 }
Exemple #23
0
        /// <summary>
        /// Método responsável por analisar a possibilidade de construir um semáforo e construí-lo quando um intervalo abrangir
        /// outro semáforo por completo, mas ainda assim existir intervalo não incorporados em outro.
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <param name="semaforoPorIntervalo">Semáforo atual</param>
        /// <param name="semaforosExistentes">Lista de semáforos existentes</param>
        /// <param name="semaforosImpactadosNovos">Lista de semáforos criados recentemente</param>
        public static void RnConstruirSemaforoQueAbrangeSemaforoAtual(short inicio, short final, SemaforoPorIntervalo semaforoPorIntervalo,
                                                                      ref List <SemaforoPorIntervalo> semaforosExistentes,
                                                                      ref List <SemaforoPorIntervalo> semaforosImpactadosNovos)
        {
            //Criando início
            int novoFinalIntervalo = semaforoPorIntervalo.inicio - 1;

            List <short> novoIntervalo = CriarIntervalo(inicio, short.Parse(novoFinalIntervalo.ToString()));

            RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);

            //Criando final
            int novoInicioIntervalo = semaforoPorIntervalo.final + 1;

            novoIntervalo = CriarIntervalo(short.Parse(novoInicioIntervalo.ToString()), final);

            RnCriarIntervaloNaoAbrangente(novoIntervalo, ref semaforosExistentes, ref semaforosImpactadosNovos);
        }
Exemple #24
0
        /// <summary>
        /// Método responsável por verificar se um intervalo está totalmente contido num semáforo já existente.
        /// </summary>
        /// <param name="inicio">Início do intervalo</param>
        /// <param name="final">Final do intervalo</param>
        /// <param name="semaforo">Semáforo já existente, o qual desejasse comparar se está contido</param>
        /// <returns>Confirmação se está ou não contido</returns>
        public static bool RnVerificarInicioFinalIntervaloEstaContidoEmOutroIntervalo(short inicio, short final, SemaforoPorIntervalo semaforo)
        {
            if (semaforo != null)
            {
                if (inicio >= semaforo.inicio && final <= semaforo.final)
                {
                    return(true);
                }
            }

            return(false);
        }