Escolar Documentos
Profissional Documentos
Cultura Documentos
Pg. 1
ndice
NDICE.......................................................................................................................................................... 1 1. BREVES NOTAS...................................................................................................................................... 2 2. TIPOS DE DADOS ................................................................................................................................... 4 3. OPERADORES......................................................................................................................................... 8 4. BLOCOS.................................................................................................................................................... 9 5. DECISES .............................................................................................................................................. 10 6. CICLOS ................................................................................................................................................... 12 7. SUBPROGRAMAS ................................................................................................................................ 14 8. EXCEPES .......................................................................................................................................... 17 9. ESTRUTURA DE PROGRAMAS ........................................................................................................ 19 10. ENTRADA E SADA............................................................................................................................ 22 11. MODELO DE CONCORRNCIA ..................................................................................................... 25 12. TAREFAS.............................................................................................................................................. 27 13. RENDEZVOUS..................................................................................................................................... 31 14. RELGIOS E TEMPORIZADORES ................................................................................................ 35 15. ATRASOS ............................................................................................................................................. 36 16. SYNCHRONOUS/ASYNCHRONOUS TASK CONTROL.............................................................. 38 17. INTERFACES....................................................................................................................................... 39 18. O PERFIL RAVENSCAR.................................................................................................................... 40 19. BIBLIOGRAFIA E RECURSOS ONLINE........................................................................................ 46
Outubro de 2006
Pg. 2
1. Breves notas
-
Em 1973 o Departamento de Defesa Norte-Americano (DoD), recenseou 450 linguagens diferentes. Da avaliao das linguagens existentes em 1976 contra um conjunto de requisitos encontrados resultou:
-
Nenhuma cumpria os requisitos Uma nica linguagem era desejvel O desenvolvimento era possvel e devia comear de uma linguagem existente, sendo as recomendadas: Pascal, PL/I e ALGOL 68 (note-se a ausncia do C) Foi escolhida a linguagem Pascal
Em 1983 foi normalizada a linguagem Ada, verificando-se, no entanto, alguma desiluso com o seu suporte a Sistemas de Tempo Real.
-
A linguagem no incorporava alguns dos avanos da altura em termos de escalonamento de Sistemas de Tempo Real. Portanto, em 1995 a primeira reviso da linguagem foi ao encontro das crticas e foi normalizada a linguagem Ada 95. Foi a primeira linguagem normalizada com suporte a orientado a objectos e sistemas de tempo-real
Em 2000 iniciaram-se os trabalho de uma nova reviso da linguagem para incorporar avanos em diversas reas (principalmente OO e STR)
-
Suporte ao perfil Ravenscar (eficincia, simplicidade e previsibilidade), a prioridades dinmicas e hierrquicas, interfaces Embora o nome seja Ada 2005, no uma nova norma mas sim um Amendment (Ada 95 Amendment 1).
O nome da linguagem uma homenagem a Ada Lovelace (filha de Lord Byron), que foi assistente de Charles Babbage, o homem que inventou o primeiro computador (computador mecnico).
-
Existe uma certa celeuma se foi Ada Lovelace ou Charles Babbage a primeira pessoa programadora da histria. No entanto, Ada Lovelace foi de certeza a primeira mulher programadora da histria.
A norma (ISO/ANSI) impe um ncleo da linguagem, mais um conjunto de Anexos especializados (Sistemas de Tempo Real, Sistemas Distribudos, Sistemas de Informao, etc.).
Os anexos definem bibliotecas e caractersticas de implementao, no acrescentam sintaxe nem vocabulrio) Qualquer compilador de Ada tem que ser validado por empresas certificadas, tendo que cumprir a norma, mas podendo no cumprir certos anexos. A linguagem especifica tambm o seu prprio executivo, permitindo utilizao mesmo sem Sistema Operativo.
Outubro de 2006
Pg. 3
O compilador GNAT talvez compilador mais utilizado (GNAT significa GNAT no um acrnimo)
-
de graa Existe para vrias plataformas (Windows, Linux, etc..) bastante eficiente (o backend o GCC)
If igual a if e igual a IF
Todas as instrues tm que levar ponto-e-vrgula (;) no fim Vrias instrues podem vir na mesma linha, desde que separadas por ; No h diferena entre um espao, ou 20 espaos, ou um fim de linha
Nota: A partir deste momento a palavra Ada ser utilizada para referir-se norma de 1995, com os acrescentos de 2005. Se necessrio, quando se referir norma de 1983, ser utilizado Ada 83 e a de 1995 ser utilizada Ada 95.
Outubro de 2006
Pg. 4
2. Tipos de dados
-
Pode-se criar um novo tipo Pode-se criar um novo tipo derivado de outro
O novo tipo herda as operaes do outro Mas os tipos so completamente independentes Por exemplo no se pode comparar varveis de um com variveis do outro
Tipos discretos
-
Enumerados:
Boolean (predefinido) Character (predefinido) -> no um inteiro, mas sim uma enumerao type Modo is (Manual, Automatico); type All_Days is (Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday); subtype Week_Days is All_Days range Monday .. Friday;
Inteiros modulares
Ada no tem inteiros sem sinal, pois facilmente se pode criar um com o range Ada tem os chamados tipos modulares em que se especifica o valor mximo, e que fazem wrap automaticamente type Byte is mod 256; Qualquer valor do tipo Byte vai de 0 a 255 ( wrap: 255 + 1 d 0, tal como 0 - 1 d 255)
Tipos Reais
-
Vrgula flutuante
Float (predefinido) type Length is digits 5 range 0.0 .. 100.0;
Vrgula Fixa
type Voltage is delta 0.125 range 0.0 .. 5.25; type Money is delta 0.01 digits 15;
Outubro de 2006
Pg. 5
No se pode usar valores de um tipo em operaes de outro tipo sem efectuar uma converso de tipo explcita Regras para subtipos so mais relaxadas Exemplos:
F: Float := 1; -- incorrecto, tem que ser: F. Float := 1.0; -- ou F. Float := Float(1);
I: Integer := 2; F: Float := 1.2; -- ... F:= F * I; -- incorrecto, tem que ser: F := F * Float(I); type Int is new Integer; A: Integer; B: Int; -- A := B; -- incorrecto, tem que ser A := Integer(B);
subtype Int is Integer range 1..10; A: Integer; B: Int; -- A := B; -- no h problema B := A; -- pode dar excepo, se A estiver -- fora da gama de valores -- de Int (1 .. 10)
Tipos Compostos
-
Arrays
String (predefinido) type Matrix is array (1 .. 4, 1 .. 4) of Integer; No h ndice obrigatrio para o incio do Array (estilo o 0 em C) Pode-se usar others para referenciar os restantes elementos de um array Exemplo:
S: String(1..10); S1: String(2..6); M: Matrix; -- ... S := 1234567890; S1 := S(5..9); -- Desde que o nmero de elementos bata certo M := ((1,2,3,4),(2,3,4,5),(3,4,5,6),(4,5,6,7)); M(1,2) := 3; S1(3) := X; S := (1 => a , 5 => z, others => 0);
Outubro de 2006
Pg. 6
Outro exemplo:
type Teacher is (Pinho, Tovar); type Module is ( introduction, scheduling, languages, dist_scheduling, fault_tolerance, development); type Modules is array (Module) of Teacher; STR: Modules; -- STR := (languages => Pinho, development => Pinho, fault_tolerance => Pinho , others => Tovar);
Records (estruturas)
type Module is record Prof: Teacher; Duration: Positive; end record; M3: Module; -- M3.Prof := Pinho; M3 := (Pinho, 3); M3 := (Duration => 3 , Prof => Pinho);
Tipos de acesso
-
Parecidos com apontadores (mas no so como os apontadores do C/C++ no so inteiros) As variveis a que se podem aceder tm que ser criadas dinamicamente Utiliza-se o . (ponto) tal como se no fosse tipo de acesso Excepto na atribuio do record todo de uma vez, em que se usa o .all
type Module is record Prof: Teacher; Duration: Positive; end record; type Access_Module is access Module; access_M2 : Access_Module := new Module; -- access_M2.Prof := Tovar; access_M2.all := (Duration => 2 , Prof => Tovar);
Outubro de 2006
Pg. 7
Atributos
-
Certos tipos tm atributos que podem ser utilizados para obter informao sobre o tipo Os atributos so referenciados atravs do caracter plica () Atributos existentes que podem ser aplicados a tipos e variveis
Size (tamanho do tipo em bits) Length (tamanho do tipo em elementos - s para arrays) Range (gama - s para tipos discretos, reais e arrays)
Este interessante mas veremos apenas nos ciclos
I: Positive; type String_10 is new String(1..10); S: String(1..10); -- I := PositiveFirst; -- I fica com 1 I := IntegerSize; -- I fica com 32 I:= SLength; -- I fica com 10 I := String_10Size; -- I fica com -- 10*8 = 80
Outubro de 2006
Pg. 8
3. Operadores
Nome
Atribuio Mdulo Diviso Resto Diviso Valor absoluto Exponenciao Multiplicao Diviso Soma Subtraco Sinal positivo Sinal negativo Igualdade Diferena Maior Menor Maior ou Igual Menor ou Igual E lgico Ou lgico Ou lgico exclusivo Negao Pertena Concatenao Gama de valores
Smbolo
:= Aritmticos mod rem abs ** * / + + Relacionais = /= > < >= <= Lgicos and and then or or else xor not Outros in & ..
Exemplo
A := B B := A mod 2 B := A rem 2 B := abs A A := 2**8 B := A * 2 B := A / 2 B := A + 2 B := A 2 A := + B A := - B; if A = 3 if A /= 3 if A > 3 if A < 3 if A >= 3 if A <= 3 if A>1 and B<2 if A>1 and then B<2 if A>1 or B<2 if A>1 or else B<2 if A>1 xor B<2 if A and not B if A in 1 .. 20 S := A & BCD 1 .. 10
Outubro de 2006
Pg. 9
4. Blocos
-
Blocos de instrues
-
possvel definir em qualquer parte um bloco de instrues, que contm uma zona de declaraes prpria
bloco ::= [identificador :] [declare {declaraes}] begin instrues; end [identificador];
Exemplos:
declare F: Float; -- F local ao bloco begin F := Obtem_valor(); F1 := F * 2.5; -- F1 vem de fora do bloco end; -- F deixa de existir aqui bloco_exterior: -- cada bloco pode ser identificado declare F: Float; -- F local ao bloco exterior begin F := Obtem_valor(); bloco_interior: declare F2: Float := 3.0; -- F2 local ao bloco interior begin F1 := F * F2; -- F1 vem de fora do bloco end bloco_interior; F1 := F1 + F2 * 2.0; -- Erro: F2 j no existe aqui end bloco_exterior; -- F deixa de existir aqui
Outubro de 2006
Pg. 10
5. Decises
-
Deciso se
Deciso-if ::= if expresso-booleana then instrues; {elsif expresso-booleana then instrues;} [else instrues;] end if;
Exemplos
if T <= 100.0 then P := Max_ Power; elsif T >= 180.0 then P := 0. 0; T := 180.0; else P := Control( R, t); end if; if estudei = true and then exame = facil then Passei; Festejar; else Estou_ca_para_o_ano; end if;
Nota: no se podem fazer atribuies dentro dos testes, s se pode ter expresses que dem true ou false
estudei : Integer := 1; if estudei and then exame = facil then -- errado, estudei no booleano Passei; Festejar; else Estou_ca_para_o_ano; end if;
Outubro de 2006
Pg. 11
Deciso caso
deciso-case ::= case expresso-discreta is alternativa {alternativa} end case; alternativa ::= when lista => nstrues; lista ::= opo {| opo} opo::= expresso | intervalo | others
Exemplo
case Dia is when Segunda => Levantar_mal_disposto; Inicio_Trabalho; when Tera .. Quinta => Continuar_Trabalho; when Sexta => Fim_Trabalho; when others => Farra
end case;
Nota: Tem que se prever todos os valores possveis da varivel. Ou ento usar a alternativa others. Se no d erro de compilao.
Outubro de 2006
Pg. 12
6. Ciclos
-
Exemplos
loop - - ciclo infinito Adquire_valor_sensor; Calcula_Controlo: Actua; end loop; V: array(1 .. 10) of Integer; -- ... for I in 1 .. 10 loop V(I) := Adquire_valor(); end loop; V: array(1 .. 10) of Integer; I : Integer := 1; -- ... while I <= 10 loop Adquire_valor(V(I)); I := I + 1; end loop;
Notas:
A varivel I no ciclo for apenas existe dentro do ciclo for. E no declarada. O atributo Range (que j foi apresentado) pode ser utilizado num ciclo for para fornecer a gama de valores de um vector for I in VRange loop Isso quer dizer que o mesmo ciclo pode ser utilizado para vectores de tamanhos diferentes, sem ser necessrio guardarmos o tamanho do vector
Outubro de 2006
Pg. 13
O exit fora a sada do ciclo para a primeira instruo seguinte Se tivermos ciclos encadeados
O exit faz sair do ciclo mais prximo Ou ento pode ser utilizado para indicar de qual ciclo queremos sair podemos dar nomes aos ciclos
V: array(1 .. 10) of Integer; -- ... ciclo_exterior: loop - - ciclo infinito for I in 1 .. 10 loop Valor:=Adquire_valor(); exit ciclo_exterior when Valor < 0; V(I):=Valor; end loop; Calcula_Controlo: Actua; end loop;
Outubro de 2006
Pg. 14
7. Subprogramas
-
E tm que retornar
A especificao (define a interface - nome e parmetros) O corpo (define a aco ou o algoritmo que executado quando se invoca o subprograma)
Exemplos de especificao
procedure Reset; -- Sem parmetros Value : in out Integer; Step : in Integer := 1);
procedure Incrementa(
in out in out
O parmetro no modificado dentro do subprograma O subprograma tem que atribui um valor ao parmetro O subprograma pode modificar o parmetro
Outubro de 2006
Pg. 15
As funes s podem ter parmetros do tipo in Por defeito os parmetros so do tipo in As formas de passar parmetros no tm nada que ver com o mtodo de passagem de parmetros
-
Se o parmetro for do tipo out ou in out temos que passar uma varivel para o subprograma (no pode ser um valor fixo) Se o parmetro for do tipo in no o podemos modificar no subprograma
Mas tm que se destinguir pelos parmetros Ou, nas funes, tambm pelo tipo de retorno
Corpo de subprogramas
corpo-de-subprograma ::= especificao-de-subprograma is {declarao} begin instrues; end nome;
O corpo tem uma parte inicial declarativa, onde se podem declarar variveis locais ao subprograma
-
Ou outros subprogramas, porque ao contrrio do C/C++ (mas tal como o Pascal) em Ada pode-se declarar subprogramas dentro de subprogramas
Uma funo tem que ter pelo menos um return, e todos os caminhos possveis dentro da funo tm que atingir um return
Outubro de 2006
Pg. 16
function Minimo(X, Y : Integer) return Integer is begin if X < Y then return X; else return Y; end Minimo; m: Integer := vec(vecFirst); begin for I in vecFirst +1 .. vecLast loop m := Minimo(vec(I) , m ); end loop; end Minimo_vector;
Invocao de subprogramas
-
procedure Reset;
procedure Incrementa( Value : in out Integer; Step : in Integer := 1); function Minimo(X, Y : Integer) return Integer; -- X : Integer := 1; begin Incrementa(X,2); Incrementa( Step => 2, Value => X);
--> associao posicional --> associao por nome -- parmetros podem ter qualquer ordem Incrementa(X); -- > parmetros por defeito Reset; -- > se no tiver parmetros -- no necessrio colocar parnteses Incrementa(X, Minimo(2,3) ); -- >funes podem ser usadas -- em expresses (procedimentos no) end;
Outubro de 2006
Pg. 17
8. Excepes
-
A aco por defeito quando uma excepo levantada terminar o programa (ou terminar a tarefa, se a excepo no for na tarefa principal) Se no queremos que termine temos que ter um processador de excepes (exception handler)
Especifica quais as excepes a processar, e o que fazer quando ocorrem
As excepes no devem ser utilizadas para situaes normais e previstas, porque tornam o programa mais lento e imprevisvel
-
O stio onde a excepo ocorre no pode ser facilmente determinado, o que pode obrigar a cdigo muito complexo
possvel desactivar as verificaes em tempo de execuo (utilizando a pragma Supress), o que deve apenas ser feito depois do programa estar completamente verificado (isto possvel?) Excepes predefinidas
-
Constraint_Error
Quando se tenta atribuir um valor for a do intervalo declarado Quando o ndice de um array est fora dos limites Quando se usa um apontador nulo Quando se produz um erro numrico (por exemplo diviso por zero)
Storage_Error
Quando se tenta reservar memria dinmica e no existe disponvel
Tasking_Error
Quando uma tarefa tenta fazer rendezvous com outra que j terminou Quando existe uma excepo na elaborao de uma tarefa, a tarefa que criou essa tarefa recebe a excepo Tasking_Error
Program_Error
Quando existe um select em que todas as opes esto fechadas (as guardas do falso) Quando uma tarefa fica bloqueada durante a execuo de um subprograma de um objecto protegido Quando um objecto protegido destrudo, mas ainda existem tarefas nas filas de espera desse objecto, essas tarefas recebem a excepo Quando a avaliao de uma barreira numa entry de um objecto protegido resulta numa excepo, todas as tarefas bloqueadas no objecto recebem Program_Error
Outubro de 2006
Pg. 18
Processamento de excepes
-
when others usado para apanhar todas as outras excepes Se o bloco onde ocorre a excepo no a processar esta enviada ao bloco mais englobante
E assim sucessivamente (o limite a tarefa)
Podemos dar um nome ocorrncia da excepo, para saber mais sobre ela
A package Ada.Exceptions tem vrios subprogramas para obter informao sobre excepes
Outubro de 2006
Pg. 19
9. Estrutura de programas
-
Existem outras: packages, tarefas e objectos protegidos Um package, um mdulo que contm declarao de tipos, variveis, subprogramas e outros packages
packages tambm so Um ficheiro fonte pode conter mais do que uma unidade de compilao
O GNAT s permite uma unidade de compilao por ficheiro
Os subprogramas e packages j compilados formam uma biblioteca de compilao Um programa executvel forma-se a partir de uma biblioteca que inclua um procedimento principal
-
Um procedimento principal Outros subprogramas e packages escritas pelo utilizador Subprogramas e packages predefinidos (possivelmente j compilados)
Quando se pretende utilizar um package necessrio utilizar clusulas de contexto logo no incio do ficheiro fonte
-
Aos ltimos chama-se filhos dos primeiros O nome do package constitudo pelo nome dos seus ascendentes separados por ponto Exemplo:
Existe uma package Ada Tem uma package filha chamada Text_IO que contm os subprogramas de interface com a consola (para texto) Assim para referenciar a package Texto_IO da package Ada usa-se:
Ada.Text_IO
Outubro de 2006
Pg. 20
-- O seguinte programa utiliza o procedimento Put da package Ada.Text_IO -- para escrever uma String (Hello World) no monitor with Ada.Text_IO; use Ada.Text_IO; procedure Hello_World is begin Put(Hello World); end Hello_World; -- Se no quisermos referenciar directamente o procedimento Put, podemos -- omitir a clusula use (agora temos que usar o caminho todo para Put) with Ada.Text_IO; procedure Hello_World is begin Ada.Text_IO.Put(Hello World); end Hello_World;
Outubro de 2006
Pg. 21
No preciso passar ao compilador a extenso .adb (mas tem que existir) O compilador cria um executvel com o nome do ficheiro fonte (sem o .adb) Para apenas compilar : gnatmake -c hello_world O compilador tem trs fases: A fase de compilao propriamente dita (gnat1) o Cria dois ficheiros: um .o (cdigo objecto) e um .ali que contm informao que vai ser utilizada nas fases seguintes (contedo dos ficheiros fontes, relao entre ficheiros, timestamp, etc)
A fase de binding (gnatbind) o Serve para verificar as relaes entre ficheiros de compilao
Outubro de 2006
Pg. 22
Como j referido existe um package que contm subprogramas para entrada/sada de texto (Ada.Text_IO)
-
Put(Item: in String); Put_Line(Item: in String); Get(Item: out String); Get_Line(Item: out String; Last: out Integer); New_Line;
Ada.Integer_Text_IO
Put(Item: in Integer); Get(Item: out Integer);
Ada.Float_Text_IO;
Put(Item: in Float); Get(Item: out Float);
Parece muita coisa (e porque temos que referenciar cada uma em separado), mas o objectivo da linguagem Ada no o de poupar na escrita de cdigo :) mas sim poupar na manuteno (o mais caro)
with Ada.TexT_IO; use Ada.Text_IO; with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedure Teste is I: Integer; begin Put(Introduza um nmero: ); Get(I); Put(O nmero introduzido foi ); Put(I); New_Line; end Teste;
------
Outubro de 2006
Pg. 23
Quando se cria uma String necessrio especificar qual o tamanho da String Quando se l uma String (tem um tamanho) com o Get somos obrigados a ler tantos caracteres como o tamanho da String Para resolver isto necessrio utilizar Get_Line, no Get Get_Line devolve tambm qual o tamanho da String lida (o segundo parmetro). A partir desse momento utilizamos sempre esse tamanho
-- O seguinte programa utiliza o procedimento Get_Line da package -- Ada.Text_IO para ler uma String (do teclado) e depois utiliza -- Put, para a colocar no monitor with Ada.Text_IO; use Ada.Text_IO; procedure Hello_Utilizador is S: String(1..80); Fim: Integer; begin Put(Introduza o seu nome (< 80 caracteres): ); Get_Line( S , Fim ); Put(Hello ); Put_Line( S( 1 .. Fim ) ); end Hello_Utilizador;
Para utilizarmos Strings sem tamanho predefinido existe um tipo de dados Unbounded_String
Os arrays podem no ter limites
Se por acaso o utilizados entrar mais de 80 caracteres os restantes caracteres ficam no buffer do teclado, o que pode originar erro nas leituras seguintes do teclado
Mas no na leitura actual. O Get_Line nunca tenta colocar na String mais caracteres do que o tamanho desta
Existe um problema quando se l uma String do teclado aps se ter lido um nmero
-
O problema no tem a ver com a linguagem, nem com o compilador ( o clebre problema do getch()) Para resolver isso, sempre que vamos ler uma string, o melhor utilizaro o procedimento Skip_Line da package Ada.Text_IO
Outubro de 2006
Pg. 24
-- O seguinte programa semelhante ao anterior, mas antes de ler o nome, -- l a idade. Logo, necessrio colocar o procedimento Skip_Line with Ada.Text_IO; use Ada.Text_IO; procedure Hello_Utilizador is S: String(1..80); Fim: Integer; Idade: Integer; begin Put(Introduza a sua idade: ); Get(Idade); Skip_Line; Put(Introduza o seu nome (< 80 caracteres): ); Get_Line( S , Fim ); Put(Hello ); Put_Line( S( 1 .. Fim ) ); Put(A sua idade ); Put(Idade); Put( anos); end Hello_Utilizador;
Outubro de 2006
Pg. 25
Ada permite a especificao de tarefas / tipo de tarefas, as quais iniciam execuo sem necessidade de activao explcita. Para comunicao / sincronizao entre tarefas temos disponveis vrios mecanismos:
-
Rendezvous (Comunicao sncrona) Objectos protegidos (Recursos partilhados - mecanismo de alto nvel) Objectos de sincronizao (mecanismo de baixo nvel)
Relgio
-
No Ada, alm de um relgio normal (Calendar) existe um relgio de tempo-real, com preciso mnima de 1S Existe um mecanismo de suspenso de uma tarefa por um tempo determinado
Atraso relativo (delay) Atraso absoluto (delay until)
Prioridades
-
Em Ada podemos especificar prioridades para tarefas, e para o tecto de prioridades de objectos protegidos As prioridades podem ser dinmicas
Podemos especificar a forma pretendida para o despacho das tarefas. O anexo de sistemas de tempo-real especifica que tem que existir pelo menos FIFO_Within_Priorities (despacho por prioridades, com FIFO na mesma prioridade
pragma Task_Dispatching_Policy(FIFO_Within_Priorities);
Podemos especificar como se comporta a interaco entre as tarefas e os recursos partilhados. O anexo de sistemas de tempo-real especifica que tem que existir pelo menos Ceiling_Locking (implementa o protocolo de Immediate Ceiling Protocol para resolver a inverso de prioridades)
pragma Locking_Policy(Ceiling_Locking);
Outubro de 2006
Pg. 26
O anexo de sistemas de tempo-real especifica que tm que existir duas formas possveis de espera no acesso a recursos: FIFO_Queuing e Priority_Queuing.
pragma Queuing_Policy(Priority_Queuing);
Quando se pretende um programa que implemente o modelo de escalonamento por prioridades, que resolva o problema da inverso de prioridades necessrio especificar
-
FIFO_Within_Priorities para o tipo de despacho, Ceiling_Locking para o acesso a recursos partilhados e Priority_Queuing para acesso a filas de espera A linguagem permite a especificao de outros modelos, para a implementao de modelos de escalonamento diferentes (e.g. EDF, Round Robin e escalonamento hierrquico)
Implementao da Concorrncia
-
A questo : Como que o Ada implementa a concorrncia A resposta : depende :) O compilador pode mapear a concorrncia nos servios disponibilizados pelo Sistema Operativo (por exemplo GNAT para Windows/Linux)
Quer dizer que o modelo de concorrncia s pode ser cumprido se o SO for de temporeal (por exemplo GNAT para VxWorks/RTEMS) fcil de implementar se o SO for de tempo-real e suporte interface POSIX
O compilador pode implementar o seu prprio runtime (por exemplo DCCI Tartan Ada Compilar ou GNAT NRT)
Directamente em cima do hardware Geralmente para arquitecturas especficas
Outubro de 2006
Pg. 27
12. Tarefas
-
So a unidade de concorrncia Declaram-se como variveis ou tipos de dados na zona de declarao dos blocos.
Declarao ::= task [type] nome [Discriminantes] [is {task_item} [private {task_item}] end [nome]]; Discriminantes::= (Nome: Tipo [{;Nome: Tipo}]) task_item::= entry|pragma Corpo::= task body nome is [{declaraes}] begin {instrues} end [nome];
As prioridades definem-se atravs de pragmas Podemos criar tarefas dentro de tarefas (hierarquia)
Outubro de 2006
Pg. 28
with Ada.Text_IO; procedure Uma_Tarefa is -- Declarao de uma tarefa task tarefa ; -- Corpo da tarefa task body tarefa is begin for Count in 1..5 loop Ada.Text_IO.Put_Line(Item => "Tarefa "); end loop; end tarefa; begin -- Inicio da tarefa principal -- A outra tarefa activada ao mesmo tempo que o corpo -- do bloco em que foi declarada for Count in 1..5 loop Ada.Text_IO.Put(Item => "Tarefa principal"); Ada.Text_IO.New_Line; end loop; end Uma_Tarefa;
Outubro de 2006
Pg. 29
with Ada.Text_IO; procedure Tarefas is -- Declarao de um tipo de tarefas task type tarefa (Msg: Character); -- Podemos utilizar discriminates nas tarefas, para poder identificar cada uma -- das tarefas -- Corpo das tarefas deste tipo task body tarefa is begin for Count in 1..5 loop Ada.Text_IO.Put_Line(Item => "Tarefa " & Msg); end loop; end tarefa; Task_A: tarefa(Msg => 'A'); Task_B: tarefa(Msg => 'B'); begin -- Inicio da tarefa principal -- As outras tarefas so activadas ao mesmo tempo que o corpo -- do bloco em que foram declaradas for Count in 1..5 loop Ada.Text_IO.Put(Item => "Tarefa principal"); Ada.Text_IO.New_Line; end loop; end Tarefas;
Outubro de 2006
Pg. 30
pragma Task_Dispatching_Policy(FIFO_Within_Priorities); -- serve para referir que este programa faz o despacho de tarefas -- por prioridades e FIFO dentro da mesma prioridade. -- uma pragma de configurao, porque aplica-se -- ao programa todo. Por isso colocada no incio with System; -- Aqui est declarado o tipo Priority with Ada.Text_Io; procedure Tarefas_Prioridades is pragma Priority(System.Priority'First); -- serve para referir que a tarefa principal tem prioridade -- igual mais baixa -- o nico stio onde se pode utilizar esta pragma na -- declarao de um subprograma -- Declarao de um tipo de tarefas task type tarefa (Msg: Character; Prio: System.Priority) is pragma Priority(Prio); -- serve para referir que este tipo de tarefa tem -- prioridade igual a Prio. Como Prio um discriminante -- que pode ser diferente para cada tarefa, a prioridade -- pode ser diferente para cada tarefa end tarefa; -- Corpo das tarefas deste tipo task body tarefa is begin for Count in 1..5 loop Ada.Text_Io.Put_Line(Item => "Tarefa " & Msg); end loop; end tarefa; Task_A: tarefa(Msg => 'A', Prio => System.Priority'First+1); Task_B: tarefa(Msg => 'B', Prio => System.Priority'First+2); begin -- Inicio da tarefa principal null; end Tarefas_Prioridades;
Outubro de 2006
Pg. 31
13. Rendezvous
-
Tarefas podem comunicar de forma sncrona entre elas Uma o cliente e outra o servidor O rendezvous pode (ou no) servir para trocar informao A tarefa servidora declara na sua interface quais os servios que disponibiliza (entries) O cliente tem que saber o nome do servidor para poder ligar Como a ligao sncrona o cliente fica bloqueado enquanto no acaba o servio no servidor Como a ligao sncrona o cliente fica bloqueado enquanto no acaba o servio no servidor Rendezvous pode ser usado para troca de dados, ou para que o servidor efectue uma aco em benefcio do cliente Esta forma de interaco parecida com o RPC
task servidor is entry servio; end servidor; task body servidor is begin -- ... accept servio; -- ... end servidor;
Outubro de 2006
Pg. 32
with Ada.Text_IO; use Ada.Text_IO; procedure Tarefas_Rendezvous is -- tarefa servidora task servidor is entry start; -- Declarao do ponto de ligao end servidor; -- Corpo da tarefa servidora task body servidor is begin accept start; -- Aqui o servidor fica bloqueado espera for Count in 1..5 loop Put_Line(Item => "Servidor"); end loop; end servidor; -- tarefa cliente task cliente; -- Corpo da tarefa cliente task body cliente is begin Put_Line("Pressione Enter para iniciar o servidor"); Skip_Line; servidor.start; -- Aqui o cliente fica bloqueado espera -- se o servidor no estiver j espera -- na entry end cliente; begin -- Inicio da tarefa principal null; end Tarefas_Rendezvous;
Outubro de 2006
Pg. 33
task servidor is entry servico1(Dados: in Tipo; Result: out Tipo); entry servico2(Dados: in Tipo); end servidor; task body servidor is begin -- ... accept servico1(Dados:in Tipo; Result: out Tipo) do -- Result:= Qualquer_coisa; end servico1; -- accept servico2(Dados: in tipo) do -- end servico2; -- ... end servidor;
Outubro de 2006
Pg. 34
with Ada.Text_IO; use Ada.Text_IO; with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; procedure Tarefas_Rendezvous2 is -- tarefa servidora task Servidor is entry Start; -- Declarao do ponto de ligao entry Servio1(Result: out Integer); entry Servio2(dados: Integer); end Servidor; -- Corpo da tarefa servidora task body Servidor is Valor: Integer := 0; begin accept Start; -- Aqui o servidor fica bloqueado espera for Count in 1..5 loop accept Servio2(dados: Integer) do Put(Item => "Servidor recebeu "); Put(dados); New_Line; Valor:= Valor + dados; end Servio2; end loop; accept Servio1(Result: out Integer) do Result:= Valor; end Servio1; end Servidor; -- tarefa cliente task Cliente; -- Corpo da tarefa cliente task body Cliente is Val: Integer; begin Put_Line("Pressione Enter para iniciar o servidor"); Skip_Line; Servidor.Start; -- Aqui o servidor fica bloqueado espera for Count in 1..5 loop Put_Line("Entre valor inteiro para enviar ao servidor: "); Get(Val); Servidor.Servio2(Val); end loop; Servidor.Servio1(Val); Put("O servidor enviou-me a soma dos valores entrados: "); Put(Val); New_Line; end Cliente; begin -- Inicio da tarefa principal null; end Tarefas_Rendezvous2;
Outubro de 2006
Pg. 35
Um relgio normal (Ada.Calendar.Clock), como se fosse um relgio de parede Um relgio de tempo real (Ada.Real_Time.Clock)
Geralmente so o mesmo relgio de hardware, mas so utilizados de forma diferente
Ada.Calendar
O tipo Time pode representar qualquer coisa (geralmente representa segundos desde as 0 horas do dia 1/1/70, como em Unix, mas no se pode garantir) A funo Clock retorna o Time actual O tipo Duration representa uma diferena de instantes. No pertence package Ada.Calendar, mas existe globalmente (package Standard) Existem funes para retirar Ano/Ms/Dia a partir do Time
Ada.Real_Time
O tipo Time pode representar qualquer coisa (geralmente o mesmo de Calendar, mas no se pode garantir) A funo Clock retorna o Time actual O tipo Time_Span representa uma diferena de instantes Existem funes para converter ms/s/ns em Time_Span
Outubro de 2006
Pg. 36
15. Atrasos
-
Relativo (delay)
Serve para indicar que a tarefa deve ficar suspensa durante um determinado instante A tarefa pode ficar bloqueada mais do que esse tempo, depende do escalonamento Usa-se: delay Intervalo; Intervalo tem que ser do tipo Duration (no pode ser Real_Time)
Quando se quer usar delay com Real_Time.Time_Span existe uma funo que converte Time_Span em Duration
Embora o atraso relativo (delay) possa ser usado, tambm pode dar problemas
Start:= Clock; Faz_Aco; delay (Start + 10.0) - Clock;
O problema que a instruo delay (Start + 10.0) Clock no indivisvel. A tarefa pode ser interrompida aps ter calculado um intervalo de 8 segundos, e quando executa outra vez j podem ter passado vrios segundos, mas o intervalo ser na mesma de 8 segundos
Outubro de 2006
Pg. 37
-- Este programa atrasa a execuo durante trs segundos -- Utilizando o tipo Duration with Ada.Text_IO; use Ada.Text_IO; procedure Relogio is Interval: Duration:= 3.0; ----Como Duration baseia-se em vrgula flutuante no pode ser := 3, tem que ser := 3.0
begin Put_Line("Comeou o programa"); delay Interval; Put_Line("Supostamente passaram 3 segundos"); end Relogio;
-- Este programa atrasa a execuo durante trs segundos -- Utilizando o tipo Ada.Real_Time.Time_Span with Ada.Text_IO; use Ada.Text_IO; with Ada.Real_Time; use Ada.Real_Time; procedure Relogio1 is Interval: Time_Span := Milliseconds(3000); -- temos que usar as -- funes de converso begin Put_Line("Comeou o programa"); delay To_Duration(Interval); Put_Line("Supostamente passaram 3 segundos"); end Relogio1;
Outubro de 2006
Pg. 38
Um semforo bsico, que pode ser usado para suspenso ou para implementar mecanismos mais complexos. Especificao (simplificada):
package Ada.Synchronous_Task_Control is type Suspension_Object is private; procedure Set_True(S : in out Suspension_Object); procedure Set_False(S : in out Suspension_Object); function Current_State(S : Suspension_Object) return Boolean; procedure Suspend_Until_True(S : in out Suspension_Object); private ... -- a implementao depende do compilador end Ada.Synchronous_Task_Control;
Um objecto tem dois estados: verdadeiro e falso. Inicialmente est a falso. O procedimento Suspend_Until_True bloqueia a tarefa no objecto at outra tarefa executar Set_True. Apenas uma tarefa pode estar suspensa num objecto (d excepo se uma segunda tentar)
No mecanismo anterior, apenas a prpria tarefa se pode suspende. O mecanismo assncrono permite que uma tarefa seja suspensa por outra:
with Ada.Task_Identification; package Ada.Asynchronous_Task_Control is pragma Preelaborate(Asynchronous_Task_Control); procedure Hold(T : in Ada.Task_Identification.Task_Id); procedure Continue(T : in Ada.Task_Identification.Task_Id); function Is_Held(T : Ada.Task_Identification.Task_Id) return Boolean; end Ada.Asynchronous_Task_Control;
Outubro de 2006
Pg. 39
17. Interfaces
-
Uma novidade do Ada 2005 foi a introduo de Interfaces (como Java). Como no existe integrao de OO com concorrncia (no se pode herdar de/para tarefas), as Interfaces podem ser usadas para permitir uma integrao limitada So permitidos 2 tipos de interfaces para serem utilizados com concorrncia:
-
Synchronised:Pode ser implementada por tarefas e objectos protegidos Task: Pode ser implementada apenas por tarefas Protected: Pode ser implementada apenas por objectos protegidos
-- A interface TI package Pkg is type TI is task interface; procedure P(X: in TI) is abstract; procedure Q(X: in TI; I: in Integer) is null; end Pkg; -- pode ser implementada por: package PT1 is task type TT1 is new TI with entry P; -- P e Q so entries entry Q(I: in Integer); end TT1; end PT1; -- ou por package PT2 is task type TT2 is new TI with entry P; -- P entry end TT2; -- Q uma procedure procedure Q(X: in TT2; I: in Integer); end PT2;
Outubro de 2006
Pg. 40
Os mecanismos de Concorrncia do Ada so muito complexos Em 1997 chegou-se concluso que era necessrio restringir a sua utilizao para:
-
Aumentar a eficincia dos executivos de tempo-real, removendo mecanismos com grandes overheads Reduzir o no determinismo para aplicaes crticas Simplificar os executivos de tempo-real, para aplicaes de alta integridade Remover mecanismos que no podem ser formalizados Remover mecanismos que impedem a anlise de resposta temporal das aplicaes
Foi ento criado o perfil Ravenscar (Reliable Ada Verifiable Executive Needed for Scheduling Critical Applications in Real-time!)
-
Ravenscar uma pequena terra no norte de Inglaterra, onde decorreu a reunio O perfil tem muitas restries No entanto, tem o suficiente para implementar aplicaes de tempo-real, segundo o modelo de escalonamento preemptivo por prioridades fixas
Pragma de configurao
pragma Profile(Ravenscar);
Outubro de 2006
Pg. 41
Restries
-
Tarefas e objectos protegidos apenas ao nvel das bibliotecas (nada de hierarquias) No permitido:
reservar/libertar dinamicamente tarefas/objectos protegidos requeue, ATC, Abort entries nas tarefas Prioridades dinmicas Ada.Calendar, Delays relativos entries nos objectos protegidos, em que a barreira no uma varivel booleana declarada dentro do prprio objecto Uma tarefa tentar executar uma entry de um objecto protegido, em que j l est outra tarefa Asynchronous Task Control Todas as formas do select Atributos de tarefas definidos pelo utilizador
Outubro de 2006
Pg. 42
Ficou ainda
Tarefas e objectos protegidos (com as restries) pragmas Atomic e Volatile delay until Ceiling_Locking e FIFO_Within_Priorities Atributo Count (mas no nas barreiras) Identificadores das tarefas Synchronous Task Control Descriminantes nas tarefas package Real_Time Protected procedures como processamento de interrupes
Cada tarefa libertada apenas por um evento, mas que pode acontecer um nmero ilimitado de vezes Este evento pode ser temporal (para uma tarefa peridica) ou espordico (de uma outra tarefa ou do ambiente). Uma aplicao critica pode restringir-se apenas a eventos temporais Tarefas apenas interagem atravs de memria partilhada, em que as actualizaes nessa memria tm que ser atmicas Depois de iniciar execuo uma tarefa no pode suspender ou ficar bloqueada
Tarefas para as actividades delay until para libertar tarefas peridicas Synchronous Task Control para libertar tarefas espordicas Objectos protegidos para libertar tarefas espordicas, com passagem de informao Objectos protegidos para memria partilhada
Estes dois tipos de objectos protegidos tm que ser independentes, no convm usar um s objecto para duas operaes diferentes
Outubro de 2006
Pg. 43
Tarefas peridicas
task body Cyclic is Next_Period : Ada.Real_Time.Time := First_Release; Period : Ada.Real_Time.Time_Span := Ada.Real_Time.Milliseconds(50); -- declaracoes begin -- Inicializacao loop delay until Next_Period; -- Codigo para a tarefa Next_Period := Next_Period + Period; end loop; end Cyclic;
Tarefas espordicas
So: Ada.Synchronous_Task_Control.Suspensaion_Object; -- tem que ser declarado com with task body Sporadic is -- Declaracoes begin -- Inicializacao loop Ada.Synchronous_Task_Control.Suspend_Until_True (So); -- Codigo da tarefa end loop; end Sporadic;
Outubro de 2006
Pg. 44
Dados partilhados
protected Shared_Data is function Get return Data; procedure Put (D : in Data ); private Current : Data; end Shared_Data; protected body Shared_Data is function Get return Data is begin return Current; end Get; procedure Put (D : in Data ) is begin Current := D; end Put; end Shared_Data;
protected type Event is entry Wait (D : out Data); procedure Signal (D : in Data ); private Current : Data; Signalled : Boolean := False; end Event; protected body Event is out Data ) when Signalled is entry Wait ( D : begin D := Current; Signalled := False; end Wait; procedure Signal ( D : in Data ) is begin Current := D; Signalled := True; end Signal; end Event;
Outubro de 2006
Pg. 45
Para o 3 mdulo de COMPA deve ser analisado o documento (tambm fornecido): Alan Burns, Brian Dobbing, George Romanski, The Ravenscar Tasking Profile for High Integrity Real-Time Programs, Reliable Software Technologies - Ada-Europe 1998 (http://www.aonix.com/pdf/ravensc.pdf)
Este documento importante para perceber os objectivos e restries do perfil Ravenscar. Est desactualizado na definio de perfil ( anterior introduo da pragma Profile), mas o que no invalida a discusso do perfil em si.
Outubro de 2006
Pg. 46
Bibliografia
1. Introduction to Concurrent Programming, captulo do livro: M.B. Feldman, Software Construction and Data Structures with Ada 95, Addison-Wesley, 1997 (http://www.seas.gwu.edu/~mfeldman/cs2-book/) 2. Ada 2005 Rationale (http://adaic.org/standards/05rat/html/RatTOC.html) 3. Alan Burns, Brian Dobbing, George Romanski, The Ravenscar Tasking Profile for High Integrity Real-Time Programs, Reliable Software Technologies - Ada-Europe 1998 (http://www.aonix.com/pdf/ravensc.pdf) 4. Burns & Wellings, Concurrency in Ada 95, Cambridge Press, 1998 5. Programming in Ada 2005, John Barnes, Addison Wesley, 2006
Normas: http://www.adaic.org/standards/ Ada Annotated Reference Manual (a norma anotada) Ada Rationale (explicao das decises tomadas na linguagem)
Outubro de 2006