Programação Paralela em occam-pi

562 visualizações

Publicada em

Projeto Final LEETC
Programação Paralela em occam-pi

Publicada em: Tecnologia
0 comentários
0 gostaram
Estatísticas
Notas
  • Seja o primeiro a comentar

  • Seja a primeira pessoa a gostar disto

Sem downloads
Visualizações
Visualizações totais
562
No SlideShare
0
A partir de incorporações
0
Número de incorporações
1
Ações
Compartilhamentos
0
Downloads
12
Comentários
0
Gostaram
0
Incorporações 0
Nenhuma incorporação

Nenhuma nota no slide

Programação Paralela em occam-pi

  1. 1. Instituto Superior de Engenharia de Lisboa Departamento de Engenharia de Eletrónica e Telecomunicações e de Computadores Licenciatura Engenharia Eletrónica de Telecomunicações e de Computadores Projeto Final LEETCProgramação Paralela em occam-pi 10 de SetembroRelatório Final 2012 Realizado por: Rui Alexandre da Silva Miranda, nº 32342 Orientado por: Engº Manuel Barata
  2. 2. Projeto Final LEETC - Programação Paralela em 2012 occam-piAgradecimentosO projeto final de curso representa pessoalmente o reconhecimento de umlongo e árduo percurso académico. A sua realização não teria sido possívelsem o apoio de certas pessoas ou entidades, às quais gostaria deagradecer.Ao DEETC e todos os seus membros, por me terem proporcionado aformação para poder realizar este Projeto Final.Ao Engenheiro Manuel Barata, por ter sugerido este projeto, ainda mais porse tratar de um tema pouco abordado, mas extremamente interessante, etambém pela disponibilidade que sempre mostrou para apoiar,inclusivamente fornecendo o microcontrolador.À minha companheira, Alina Bordalo, a qual me deu forças para continuarmesmo nas altura mais difíceis. 2
  3. 3. Projeto Final LEETC - Programação Paralela em 2012 occam-piResumoEste projeto tem como objetivo a criação de uma máquina virtual, e todosos seus recursos subjacentes, para que seja possível correr um programaoccam-pi sobre um microcontrolador da família PIC32. Com isto pretende-se a abstração do Hardware em relação à linguagem do Software,alcançando assim um nível de portabilidade e eficiência na escrita de códigoparalelo num sistema embebido de tempo-real, superior à actual.Como suporte ao desenvolvimento do projeto foi necessária a aprendizagemde todas as tecnologias envolvidas: linguagem de programação paralelaoccam-pi [2]; arquitetura do microprocessador Transputer [14]; programaçãoC no microcontrolador PIC32 [8].Para implementação desta máquina virtual foi necessário, proceder àmigração da máquina virtual do Transputer (TVM) [4], do sistema POSIXpara o sistema embebido, PIC32. Após a migração, foi desenvolvida umapequena biblioteca de funções para abstração do Hardware (HAL). Foitambém desenvolvida uma aplicação, a executar ambiente Linux, para ocarregamento no PIC32 dos bytecodes do programa occam já compilado,através da porta série (USB).O objetivo final do projeto consiste na execução de uma aplicação dedemonstração desenvolvida em occam-pi, na máquina virtual implementadano Kit com um microcontrolador PIC32. 3
  4. 4. Projeto Final LEETC - Programação Paralela em 2012 occam-piÍndiceAgradecimentos ............................................................................................................................ 2Resumo.......................................................................................................................................... 3Índice ............................................................................................................................................. 4Índice de Figuras ........................................................................................................................... 6Índice de exemplos ....................................................................................................................... 61. Enquadramento Teórico ................................................................................................... 71.1. Sistemas Embebidos de Tempo-Real ........................................................................ 71.2. Programação Paralela ............................................................................................... 72. Estudo Desenvolvido ......................................................................................................... 82.1. Transputer ................................................................................................................. 8 2.1.1. Registos ............................................................................................................. 8 2.1.2. Instruções .......................................................................................................... 8 a) Funções Diretas ......................................................................................................... 8 b) Funções de Prefixo .................................................................................................... 9 c) Funções Indiretas ...................................................................................................... 9 2.1.3. Processos e Concorrência.................................................................................. 9 2.1.4. Prioridade de Processos .................................................................................. 10 2.1.5. Comunicação entre Processos ........................................................................ 10 2.1.6. Temporizadores............................................................................................... 102.2. Occam ...................................................................................................................... 11 2.2.1. Características Principais ................................................................................. 11 2.2.2. Exemplo ........................................................................................................... 112.3. Projeto KRoC ........................................................................................................... 13 2.3.1. Compilador occam .......................................................................................... 13 2.3.2. Interpretador ................................................................................................... 13 a) Tradução.................................................................................................................. 13 b) Run-Time ................................................................................................................. 14 c) Funções tipo sffi ...................................................................................................... 15 2.3.3. Teste ................................................................................................................ 172.4. PIC32MX460 ............................................................................................................ 18 4
  5. 5. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 2.4.1. Características Principais ................................................................................. 18 2.4.2. Hardware de Desenvolvimento....................................................................... 18 2.4.3. Software de Desenvolvimento ........................................................................ 19 a) Desenvolvimento .................................................................................................... 19 b) Compilação .............................................................................................................. 20 c) Carregamento.......................................................................................................... 20 d) Teste ........................................................................................................................ 21 2.4.4. Rotina main ..................................................................................................... 213. Projecto ........................................................................................................................... 223.1. Implementação ....................................................................................................... 223.2. Arquitetura .............................................................................................................. 223.3. Migração TVM ......................................................................................................... 24 3.3.1. Estrutura Main................................................................................................. 24 a) Linux ........................................................................................................................ 24 b) PIC32........................................................................................................................ 24 3.3.2. Compilação PIC32 ............................................................................................ 24 a) Heap size ................................................................................................................. 24 b) No Floating Point ..................................................................................................... 25 c) Macro TVM .............................................................................................................. 253.4. PIC32 HAL ................................................................................................................ 26 3.4.1. Temporização da TVM..................................................................................... 26 3.4.2. Módulo sffi ...................................................................................................... 27 a) Código C da TVM ..................................................................................................... 27 b) Código occam .......................................................................................................... 283.5. Carregamento do programa occam ........................................................................ 30 3.5.1. Programa de envio .......................................................................................... 30 a) Comando de execução ............................................................................................ 30 b) Leitura do ficheiro tbc ............................................................................................. 30 c) Envio dos bytecodes ................................................................................................ 30 3.5.2. Rotina de receção no PIC32 ............................................................................ 303.6. Occam-pi Demos ..................................................................................................... 32 5
  6. 6. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.6.1. Botões e LEDs .................................................................................................. 32 3.6.2. Timer ............................................................................................................... 333.7. Software Desenvolvido ........................................................................................... 34 3.7.1. Ambiente Windows XP .................................................................................... 34 3.7.2. Ambiente Linux ............................................................................................... 344. Conclusão ........................................................................................................................ 355. Bibliografia ...................................................................................................................... 36Índice de FigurasFigura 1 - Transputer T425 ............................................................................................................ 8Figura 2 – Lista Ligada de Processos de Baixa Prioridade ........................................................... 10Figura 3 - FIFO em occam-pi ........................................................................................................ 11Figura 4 - Execução fifo.tbc ......................................................................................................... 12Figura 5 – Correspondência de tipos entre occam e C ............................................................... 15Figura 6 – Função interface e correspondentes tipos ................................................................. 15Figura 7 – Output teste TVM ....................................................................................................... 17Figura 8 - UBW32 ........................................................................................................................ 18Figura 9 - MPLAB IDE ................................................................................................................... 19Figura 10 - MPLAB C32 Compiler ................................................................................................ 20Figura 11 – Bootloader ................................................................................................................ 20Figura 12 – Terminal.................................................................................................................... 21Figura 13 - Diagrama da Maquina Virtual occam-pi.................................................................... 22Índice de exemplosExemplo 1 – Rotina main da TVM ............................................................................................... 14Exemplo 2 – Programa occam de teste da TVM ......................................................................... 17Exemplo 3 – Rotina main PIC32 .................................................................................................. 21Exemplo 4 – Inicialização do Timer PIC32 ................................................................................... 26Exemplo 5 – Leitura do Timer PIC32 ........................................................................................... 26Exemplo 6 – Funções interface LEDs ........................................................................................... 27Exemplo 7 – Funções interface Switches .................................................................................... 28Exemplo 8 – Biblioteca de Funções HAL do PIC32 para occam (pic32.hal)................................. 29Exemplo 9 – 08_switch2.occ ....................................................................................................... 32Exemplo 10 – 09_delayled.occ .................................................................................................... 33 6
  7. 7. Projeto Final LEETC - Programação Paralela em 2012 occam-pi1. Enquadramento Teórico 1.1. Sistemas Embebidos de Tempo-Real[1] Com o exponencial crescimento da indústria de tecnologias móveis nasúltimas décadas, cada vez mais se dá importância a sistemas embebidos,como por exemplo microcontroladores. Estes sistemas são definidos comosistemas de computação com os recursos estritamente necessários paraexecutar uma função específica. Atualmente o uso de sistemas embebidos épraticamente global, tendo aplicações tanto em ambientes privados comoem ambientes empresariais.Ainda no atual panorama tecnológico cada vez mais são necessáriossistemas de tempo-real, estes sistemas podem ser definidos como sistemasque respondem a eventos externos de forma pronta.Da junção dos dois conceitos descritos anteriormente, surge outro tipo desistema, o sistema embebido de tempo-real, que abrange os principaisaspetos dos outros dois. Os sistemas embebidos de tempo-real têm os maisdiversos tipos de aplicações atualmente, como por exemplo em veículosmotorizados, sistemas de telecomunicações, entre outros. 1.2. Programação Paralela[4] Com a introdução de sistemas de tempo-real, vem a necessidade de umaprogramação mais eficiente no que toca a tempos de execução, fazendo usode múltiplas unidades de processamento de um sistema, de sistemas emrede partilhando recursos, ou de ambos, é possível um programa executarvarias instruções em simultâneo, este modelo de computação é designadopor programação paralela. Das mais diversas linguagens que suportamprogramação paralela, temos a occam. Esta linguagem foi desenvolvida em1980 por uma equipa da INMOS como linguagem nativa do seumicroprocessador Transputer, e baseada na teoria de T. Hoare, CSP(Communicating Sequential Process). Uma das principais funcionalidadesdesta linguagem é a concorrência entre processos e comunicação entreeles. A gestão da concorrência entre processos paralelos é feita através dacomunicação entre os mesmos através de canais síncronos. A universidadede Kent (Reino Unido) tem vindo a dar continuidade ao estudo e aplicaçãodo occam, sendo a versão mais recente o occam-pi, desenvolvida pelaequipa KRoC (ver 2.3). Mantendo assim ativo este paradigma deprogramação que para além de poder ser executado por um processador,pode também ser usado para programar arquiteturas com vários núcleosprocessadores, ou até mesmo ser diretamente compilada para execução emHardware programável (e.g. FPGA). Atualmente existem disponíveis váriasferramentas para desenvolver e testar programas occam, sendo estascódigo aberto e livre. Uma delas é o TRANSTERPRETER que utilizando umamáquina virtual emula um processador que executa código compilado dooccam. O código dessa máquina virtual é simples e passível de ser migradopara execução em qualquer processador de 8, 16 ou 32 bit. 7
  8. 8. Projeto Final LEETC - Programação Paralela em 2012 occam-pi2. Estudo Desenvolvido 2.1. Transputer[5] Nos anos 80 a companhia de semicondutores INMOS produziu oTransputer (Figura 1 - Transputer T425), um inovador microprocessador de altaperformance desenhado para computação paralela. OTransputer possui 4 canais série integrados, quepermitem a ligação dos microprocessadores entre si.Neste contexto surge a linguagem occam, desenhadaespecificamente para programar no Transputer, com umaligação muito mais forte ao Hardware do que linguagenscomo C ou Pascal em relação aos processadores dearquitetura CISC (Complex Instruction Set Computer).[14] Uma das versões mais reconhecidas do Transputer foiFigura 1 - Transputertem a T800, que T425como características principais: processador a 32 bits com umaperformance de 15 MIPS (Million of Instruncions per Second); unidadeinterna de floating poit a 64 bits; 4 Kbytes de RAM interna com umavelocidade de escrita/leitura de 120Mbytes/seg; dois temporizadoresinternos; etc. Das principais utilizações deste microcontrolador, destacam-se: aplicações matemáticas e científicas; processamento gráfico de altaperformance; supercomputadores; etc. 2.1.1. Registos[14] Existem 6 registos disponíveis para a execução de processossequencialmente, a razão de ser um número reduzido deve-se ao facto, doTransputer ter ao seu despor RAM com uma rápida velocidade deescrita/leitura. Os 6 registos são: ponteiro do Workspace, que aponta parao local onde se encontram as variáveis locais; ponteiro da próxima instruçãoa ser executada; o operando da instrução; três registos para avaliação dasoperações, A, B e C; 2.1.2. Instruções[14] Cada instrução é composta por 1 byte, onde os 4 bits de maior pesorepresentam o código da função, e os 4 bits de menor peso contêm o valordos dados. Os bits de dados são carregados nos 4 bits menos significativosdo registo de operando. a) Funções Diretas[14] A representação das funções permite a codificação de 16 funções, comum valor possível de dados entre 0 e 15. Treze dos valores possíveis paracodificações de funções, são usados para as instruções mais comuns, comocarregamento/soma de constantes/variáveis locais, Jump, Call, entreoutras. 8
  9. 9. Projeto Final LEETC - Programação Paralela em 2012 occam-pi b) Funções de Prefixo[14] Por forma a possibilitar nas funções utilização de dados com valoressuperior a 15 (codificação com 4 bits), existem dois códigos de funçõesdisponíveis: prefixo e prefixo negativo. A função prefixa carrega conteúdodos dados (4 bits de menor peso do byte de instrução) nos 4 bits de menorpeso do registo de operando, e desloca o mesmo registo 4 posições nadireção de maior peso. A única diferença da função de prefixo negativoconsiste na negação bit a bit do registo operando, antes da deslocação. Épossível assim através de uma sequência de instruções prefixo a operaçãode valores de dados de qualquer valor até ao máximo suportado peloregisto operando. c) Funções Indiretas[15] O último valor disponível codifica a função operate, esta faz com que doconteúdo registo operando seja interpretado como um código de operaçãoda instrução a ser executada. 2.1.3. Processos e Concorrência[14][15] Um processo é uma sequência de instruções, sendo executado comsuporte nos 6 registos existentes (ver 2.1.1). O Transputer permite aexecução de vários processos em paralelo (concorrentemente), neste casocada um dos processos tem um espaço de memória reservado para orespetivo Workspace. Este Workspace é usado para guardar variáveis locais,e valores temporários manipulados pelo processo.O processador contém um Scheduler internamente programado, que gere oTime-Slice atribuído a cada um dos processos paralelos, eliminando assimprocessamento desnecessário de processos inativos (um processo pode ficarinativo se estiver a aguardar input/output, ou se estiver a aguardar por umtempo especifico).Os processos ativos em espera para ser executados são colocados em duaslistas ligadas (Alta prioridade, e baixa prioridade: ver 2.1.4). Cada uma daslistas é implementada com base em 2 registos, um que aponta para oprimeiro processo da lista, o outro para o ultimo. Como pode ser visto naFigura 2 – Lista Ligada de Processos de Baixa Prioridade, o processo S está a serexecutado, enquanto estão em espera os processos P,Q e R. Para osprocessos de alta prioridade o esquema é o mesmo, mudando somente adesignação dos apontadores de início e fim da lista, para FPtr0 BPtr0,respetivamente. 9
  10. 10. Projeto Final LEETC - Programação Paralela em 2012 occam-pi Figura 2 – Lista Ligada de Processos de Baixa Prioridade 2.1.4. Prioridade de Processos[14] O conceito de prioridade de processos, foi uma especificação que surgiucom o Tranputer T800. Existem dois níveis de prioridade: baixa (prioridade1) e alta (prioridade 0), os processos de prioridade baixa só tem direito aTime-Slice quando não existe nenhum processo de prioridade alta ativo. 2.1.5. Comunicação entre Processos[14][15] Por forma a permitir a comunicação e sincronização entre processosconcorrentes existem canais, estes canais série síncronos permitem acomunicação dentro do Transputer (no mesmo programa através deendereço de memória), ou a comunicação com o exterior (entre Transputersdiferentes através de canais séries). O processo que chegar primeiro àinstrução de input/output do canal fica inativo enquanto o outro processonão chega também à sua instrução de output/input respetiva, quando osegundo chega os dados são transferidos através do canal e cada um dosprocessos continua com a sua execução. 2.1.6. Temporizadores[14] Estão ainda disponíveis para utilização dois temporizadores de 32 bitsinternos ao Transputer. O Timer0 (Período de 1 microssegundo) é acedidoapenas por processos de alta prioridade, enquanto o Timer1 (Período de 64microssegundos) é acedido apenas por processos de baixa prioridade. 10
  11. 11. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 2.2. Occam 2.2.1. Características Principais[6] O modelo occam permite a concorrência, mais especificamente, overdadeiro paralelismo em multiprocessadores, ou paralelismo simuladonum único processador através da técnica de “Time-Slicing”, este segundoserá o utilizado para implementar a máquina virtual no PICMX32, visto queeste possui um único processador de 32bits.O paralelismo occam é ao nível da instrução, isto significa que semindicação contrária, cada instrução é interpretada como um processo,podendo ser executada em concorrência com outras. A comunicação entreprocessos concorrentes é feita através de canais síncronos, ou seja, quandodois processos partilharem um canal sempre que um chegar a umalocalização do código onde lê de um canal esse mesmo processo aguardaaté que o outro escreva no mesmo canal, e assim transferem informaçãoentre si. 2.2.2. ExemploPara a investigação da Linguagem occam, mais especificamente da últimaversão occam-pi, e das suas funcionalidades foram feitos vários testes eexperimentações através do programa emulador de occam-pi/Transputer,Transterpreter [7]. De um dos programas de teste feitos destaca-se aimplementação de uma Lista FIFO através da Linguagem occam-pi,funcionamento descrito na Figura 3 - FIFO em occam-pi. Figura 3 - FIFO em occam-pi 11
  12. 12. Projeto Final LEETC - Programação Paralela em 2012 occam-piPara teste da lista FIFO, é lido um carácter do teclado e colocado no canalde entrada da FIFO, após um delay, é consumido o carácter no canal desaída, resultando da execução deste programa de teste Figura 4 - Execuçãofifo.tbc. Figura 4 - Execução fifo.tbc 12
  13. 13. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 2.3. Projeto KRoC[4][16] KRoC, ou Kent Retargetable occam Compiler, é uma plataforma open-source para a linguagem occam/occam-pi, composta por um compilador deoccam, tradutor de código nativo do Transputer, e sistemas de run-time(com suporte a diferentes ambientes). Este projeto de investigação continuaativo na universidade Kent (Reino Unido).Atualmente esta plataforma suporta os seguintes sistemas operativos:  Linux  FreeBSD  MacOS X  Windows (através do Cygwin)  Arduino (ou sistemas embebidos semelhantes)  NxOS [17](sistema operativo embebido do robot LEGO Mindstorms NXT [18]) 2.3.1. Compilador occamO compilador de occam da plataforma KRoC (occbuild) trata de compilar osficheiros de código occam/occam-pi (occ), gerando o ficheiro com osbytecodes correspondentes do Transputer (tbc). Este processo éindependente do ambiente sobre o qual vamos correr o programaoccam/occam-pi. 2.3.2. InterpretadorA tradução e o run-time, ou interpretação dos bytecodes, ficam a cargo daTVM (Transputer Virtual Machine), esta com respetiva implementação paracada um dos ambientes sobre os quais se pretende correr o programaoccam/occam-pi.A implementação escolhida para estudo, e posterior migração, foi a dosistema NxOS/NXT, isto por ser a que continha menos dependências paracom o hardware/sistema. Passando a explicar o funcionamento da TVM: a) TraduçãoO ficheiro tbc é passado como parâmetro da TVM, este é lido e os seusbytes colocado num array, tbc_data, após isto o array é descodificado paraum formato de contexto de execução das instruções do Transputer. Aestrutura da variável de contexto, context, é composta por diversosobjetos que especificam o processador a emular, o Transputer, como osregistos do mesmo (ver 2.1.1), e outras variáveis e ponteiros de funçõespara suporte à execução do programa occam/occam-pi sobre a TVM. 13
  14. 14. Projeto Final LEETC - Programação Paralela em 2012 occam-pi b) Run-TimeApós a iniciação da TVM, carregamento do tbc e respetiva descodificação, éiniciada a rotina de execução do programa occam/occam-pi. Esta rotina éexecutada enquanto o programa não terminar, por defeito é executada umainstrução do contexto por ciclo da rotina, após esta execução é avaliado oseu retorno (para ver se a TVM encontro algum erro, a execução encontra-se em espera por um tempo especifico, ou o programa terminou). Parte darotina main pode ser vista no Exemplo 1.A execução da instrução resume-se à chamada da funçãodispatch_instruction, recebendo o contexto e o código da instrução a serexecutada, mapeia o código da instrução para a função respetiva, sendonessa função manipulado o conteúdo do contexto, por forma a executar ainstrução passada.A maior parte destas funções mapeadas, são a transcrição direta dasinstruções do Transputer (ver 2.1.2), existindo outras especificas de certasfuncionalidades do occam-pi, e por fim existe a instrução de chamada afunções do tipo ffi/sffi (Foregin Function Interface/Special Foregin FunctionInterface) ver c).Exemplo 1 – Rotina main da TVM 14
  15. 15. Projeto Final LEETC - Programação Paralela em 2012 occam-pi c) Funções tipo sffi[20] As funções do tipo ffi/sffi permitem a chamada direta a partir doprograma occam/occam-pi a funções características do ambiente.Estas funções interface têm de ser definidas, declaradas e atribuídas aoarray de funções sffi no módulo homónimo, com o seguinte cabeçalho: int interface_function_name (ECTX ectx, WORD W[])Na implementação desta função interface será chamada a função específicade C, devendo esta ser definida noutro módulo (boa prática). Ao chamaresta função é necessário ter atenção para com o mapeamento dos tipos, jáque o elementos do array parâmetro de entrada é do tipo especifico daTVM, WORD, o qual não terá o mesmo significado que o tipo WORD doPIC32.O parâmetro array W[], contem todos os parâmetro de entrada da funçãooccam/occam-pi, estando o primeiro parâmetro de entrada na posição zero,e os restantes em diante.Nas figuras abaixo (Figura 5 e Figura 6) pode-se observar todo o mapeamentodeste da função occam, à interface, até à função C. Figura 5 – Correspondência de tipos entre occam e C Figura 6 – Função interface e correspondentes tipos 15
  16. 16. Projeto Final LEETC - Programação Paralela em 2012 occam-piJá em código occam/occam-pi é necessário declarar o seguinte protótipo:#PRAGMA EXTERNAL "PROC C.tvmspecial.X.interface.function.name (VAL BYTE C,…) = 0"INLINE PROC interface.function.name (VAL BYTE c,…) C.tvmspecial.X. interface. function.name (c,…):Onde a diretiva #PRAGMA EXTERNAL indica ao processador que aimplementação desta função é externa ao sistema occam. A letra C a seguira PROC indica à TVM que terá que gerar uma chamada especial (sffi) a umafunção C. VAL BYTE C é apenas um exemplo de um parâmetro de entradada função. O atributo a redefinição INLINE serve apenas para simplificar onome da função no código occam. 16
  17. 17. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 2.3.3. TestePara testar a TVM, do sistema NXT/NxOS, foi necessário efetuar ligeirasalterações para permitir a execução da mesma em ambiente Linux,nomeadamente:  Removida a rotina de carregamento do programa occam/occam-pi via USB.  Acrescentada função, read_tbc_file, para carregamento do programa occam/occam-pi através argumento da linha de comandos.  Removidas todas as funções específicas do sistema NXT/NxOS.  Acrescentadas algumas funções básicas do tipo sffi, para permitir o debug imediato de alguns testes (put_char/get_char).O programa occam a testar, 00_hello.tbc, foi o mais básico possível,apenas faz o print para a consola do valor 33 (ver Exemplo 2), o ouputda sua execução pode ser visto na Figura 7 – Output teste TVM.Exemplo 2 – Programa occam de teste da TVM--aqui definimos a chamada à função sffi, que se encontra na posição 1--do array de funções sffi#PRAGMA EXTERNAL "PROC C.tvmspecial.1.put.char1 (VAL BYTE C) = 0"INLINE PROC put.char1 (VAL BYTE ch) C.tvmspecial.1.put.char1(ch):--ponto de entrada do programaPROC hello () SEQ put.char1(33): Figura 7 – Output teste TVM 17
  18. 18. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 2.4. PIC32MX460 2.4.1. Características Principais[8][9] O PIC32MX460 é um microcontrolador da família PIC32, estedispositivo permite uma velocidade de processamento superior a 80 DMIPS(Dhrystone Million of Instruncions per Second) e tem uma grande variedadede periféricos integrados. Uma característica específica da família PIC32MXé facilidade de migração da aplicação, que tem todo o seu interesse numprojeto deste âmbito. 2.4.2. Hardware de Desenvolvimento[8][10][11] O Kit de desenvolvimento utilizado para a implementação damáquina virtual de occam-pi no PIC32MX460, foi o UBW32 (Figura 8 - UBW32).Este Kit permite a ligação via USB ao computador, por onde é possívelcarregar os programas desenvolvidos e ainda receber/enviar input/outputpara o PIC32MX460. Contem 2 botões/Switches e 4 LEDs, programáveispelo utilizador, como também 78 Pinos I/O disponíveis para utilização. Emtermos de performance, o PIC32MX460 opera a uma frequência de 80MHz,tem 32Kbytes de RAM, e 512Kbytes de Flash. Figura 8 - UBW32 18
  19. 19. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 2.4.3. Software de Desenvolvimento[9] O ciclo de desenho de código para a máquina virtual occam-pi écomposto pelos seguintes passos: a) DesenvolvimentoO IDE utilizado para o desenho de todo código e bibliotecas C, tanto para ointerpretador de occam-pi (Loader da Figura 13 - Diagrama da Maquina Virtual occam)como para a interface com o hardware do microcontrolador (HAL da Figura 13- Diagrama da Maquina Virtual occam), é o MPLAB v8.63 (Figura 9 - MPLAB IDE) daMicrochip [12]. Figura 9 - MPLAB IDE 19
  20. 20. Projeto Final LEETC - Programação Paralela em 2012 occam-pi b) Compilação[13] Este IDE tem integrado um compilador C32 (Figura 10 - MPLAB C32 Compiler),esta integração traz uma agilidade no processo de escrita de código C parao PIC32 e compilação do mesmo. Este compilador permite referênciasdiretas às bibliotecas de periféricos do PIC32, que por sua vez fazemchamadas a funções built-in do PIC32 (ex: Funções de Interrupção, Funçõesde Timer, etc), e também a macros como pragma e outras. Figura 10 - MPLAB C32 Compiler c) CarregamentoPara carregamento do código compilado no PIC, é utilizado o Bootloader daMicrochip (Figura 11 – Bootloader), que permite o carregamento via USB. Figura 11 – Bootloader 20
  21. 21. Projeto Final LEETC - Programação Paralela em 2012 occam-pi d) TesteFinalmente como aplicação para suporte aos Testes, foi usado oHyperTerminal do Windows (Figura 12 – Terminal), que permite interação I/Ocom o PIC32 via USB. O Terminal foi de extrema importância nodesenvolvimento, isto porque apenas se pôde recorrer a printfs como formade Debug. Figura 12 – Terminal 2.4.4. Rotina mainNo PIC32, a rotina normal de execução da função main (ver Exemplo 3) é aseguinte: 1. Iniciações do sistema, hardware e periféricos 2. Ciclo infinito, aqui o programa terá que atender a cada um dos processos atempadamente: a. Tarefas do dispositivo USB, como por exemplo, input/output da porta série, entre outras. b. Processo input/output da aplicação em sim, ou seja, o nosso programa/execução da máquina virtual. Uma nota importante é que este processo não pode ser bloqueante, o que significa, que tem que retornar ao ciclo infinito periodicamente para executar as tarefas descritas em a.Exemplo 3 – Rotina main PIC32 21
  22. 22. Projeto Final LEETC - Programação Paralela em 2012 occam-pi3. Projecto 3.1. Implementação[3] Existem duas formas de implementar a máquina virtual: traduzindodiretamente para o código ASM do processador alvo, ou então implementarum simulador das instruções da máquina virtual. Neste projeto, por setratar de uma abordagem exploratória, optou-se pela versão com instruçõessimuladas/interpretadas. Foi também necessário desenvolver uma pequenabiblioteca de interface entre o programa e os aspetos de I/O específicos doprocessador a utilizar. A máquina virtual foi desenvolvida para operar sobreo microcontrolador PIC32MX460, mas o desenvolvimento foi em vista apoder migrar para qualquer outro processador. 3.2. Arquitetura Figura 13 - Diagrama da Maquina Virtual occam-pi 22
  23. 23. Projeto Final LEETC - Programação Paralela em 2012 occam-piComo está representado na Figura 13 - Diagrama da Maquina Virtual occam, aimplementação da Maquina Virtual de occam está dividida em 2 módulosprincipais:  Loader, Descodificador de programas occam-pi, que recebe os ficheiros executáveis occam-pi (código já compilado e ligado com as bibliotecas de runtime do occam-pi) e descodifica para instruções simuladas do processador alvo, PICMX32.  HAL (Hardware Abstraction Layer), Interface de interligação com o PICMX32, interface constituída pelas bibliotecas de interação das instruções simuladas do descodificador com as funcionalidades do microprocessador. 23
  24. 24. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.3. Migração TVMNeste subcapítulo será descrito todo o processo de migração da TVM NXT(já com alterações para execução em ambiente Linux) para o PIC32. 3.3.1. Estrutura Main a) LinuxEm primeiro lugar, ainda em ambiente Linux, teve que se proceder àalteração da estrutura main do programa TVM (ver Exemplo 1). Isto paraintegrar na rotina main do PIC32 (ver 2.4.4).Nesta fase inicial optou-se por colocar os bytes do tbc hardcoded, numficheiro header auxiliar, tbc_data.h (posteriormente já no PIC32 foiimplementada uma rotina de carregamento do tbc via porta série, ver 3.5).Foi criada uma função geral de iniciação da tvm, e do contexto a partir dosbytes do tbc, main_init_tvm(). Foi também alterada a rotina de execuçãoda tvm, para algo semelhante a uma maquina de estados, sendomain_run_tvm() a função de passagem. b) PIC32Já no PIC32, foi utilizada como base a aplicação de firmware do kit UBW32[19]. Esta aplicação permite a interpretação de alguns comandos parainteragir diretamente com o hardware do microcontrolador. Foi removido ocódigo de interpretação destes comandos, ficando apenas o echo decaracteres enviados, o que foi útil para debug.A estrutura do main pós migração pode ser vista em anexo((CD)SoftwareMPLAB-WORKTVM_D32main.c), onde já se encontraimplementada a rotina de leitura dos bytecodes do tbc via porta serie (oprograma Linux de envio encontra-se descrito em 3.5) 3.3.2. Compilação PIC32Tiveram que ser acrescentadas as seguintes opções de compilação aoprojeto MPLAB: a) Heap sizeDefinição de Heap size para permitir o uso da função de biblioteca C mallocna alocação do espaço em memória para o contexto do programaoccam/occam-pi. Foi escolhido o valor de 16384 bytes por ser um tamanhomais que suficiente para qualquer programa occam/occam-pi, deixandoainda uma boa margem para o funcionamento de todo o programa noPIC32, que tem um total de 32Kbytes de RAM (2.4.2). No entanto poderáser ainda otimizado o valor do Heap size, caso haja necessidade de carregarprogramas occam/occam-pi de maior dimensão, ou se 16Kbytes fordesnecessário.Para efetuar esta configuração no MPLAB é necessário seguir os seguintespassos: i. (MPLAB)>Project>Build Options…>Project ii. MPLAB PIC32 Linker>Heap size: 16384 bytes 24
  25. 25. Projeto Final LEETC - Programação Paralela em 2012 occam-pi b) No Floating PointPara simplificação da implementação da máquina virtual optou-se por nãoincluir a funcionalidade de floating point do occam-pi, logo não seránecessário incluir as bibliotecas C de floating point no projeto MPLAB. Paraisso é necessário acrescentar a seguinte opção na compilação do projeto: i. (MPLAB)>Project>Build Options…>Project ii. MPLAB PIC32 C Compiler>(uncheck) Exclude floating-point libraryPara compilar o projeto sem erros foi também necessário comentar oualterar certas funções da biblioteca da TVM, libtvm, especificas dasfuncionalidades de floating point do occam-pi. c) Macro TVMEm último lugar foi necessário definir uma Macro de pré-processamento,TVM_INTERNALS, isto para que a tvm defina macros para alguns dosobjetos da variável de contexto (ver Run-Time), tornando assim o códigomais legível. Para definir esta marcro é necessária a seguinte configuração: i. (MPLAB)>Project>Build Options…>Project ii. MPLAB PIC32 C Compiler>Preprocessor Macros>Add… iii. “TVM_INTERNALS” >OK 25
  26. 26. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.4. PIC32 HALNeste subcapítulo será descrito todas as funções criadas para abstração damáquina virtual para com o hardware do PIC32. Em todas estas funçõesforam utilizadas as bibliotecas de periféricos do PIC32 [13]. 3.4.1. Temporização da TVMPara o funcionamento de certas funcionalidades occam/occam-pi, comoinstruções paralelas (PAR) nomeadamente na gestão do time slice, ou oacesso ao temporizador (TIMER), foi necessário configurar o Timer do PIC32(Exemplo 4), e implementar a função stub da TVM de leitura do Timer (Exemplo5). Esta função é utilizada internamente pela máquina virtual, não podendoser chamada através do código occam/occam-pi. Para ter acesso aotemporizador emulado deverá utilizar-se a variável do tipo Timer de occam.Exemplo 4 – Inicialização do Timer PIC32Exemplo 5 – Leitura do Timer PIC32 26
  27. 27. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.4.2. Módulo sffiNo módulo sffi (Special Foregin Function Interface) foram definidas algumasfunções para interação direta com os periféricos do PIC32 através de códigooccam/occam-pi, ver 2.3.2.c). Por este projeto ser de caris exploratório,foram definidas apenas funções para interação com os 3 LEDs e 2 Switchesdo PIC32. No futuro poderão também ser implementadas funções deinteração com os pinos I/O. a) Código C da TVMPara utilização destes periféricos é necessário proceder previamente à suainicialização, fazendo uso das funções de biblioteca mInitAllLEDs() para osLEDs, e mInitAllSwitches() para os Switches.Quanto à interação propriamente dita: i. Para os LEDs foram definidas as funções interface, _mLED_X_[On/Off/Toggle]_e(ECTX ectx, WORD W[]), em que X vai de 2 a 4 (indicador do LED em questão), que chamam funções intermédias, funções estas que por sua vez chamam as funções da biblioteca do PIC32 mLED_X_[On/Off/Toggle](). Nestas funções sffi os parâmetros de entrada nunca são utilizados, mas a sua definição tem de estar em conformidade com o formato das funções interface. Este mecanismo encontra-se descrito no Exemplo 6.Exemplo 6 – Funções interface LEDs 27
  28. 28. Projeto Final LEETC - Programação Paralela em 2012 occam-pi ii. Para os Switches foram definidas as funções interface, _swProgram_e(ECTX ectx, WORD W[])e _swProgram_e(ECTX ectx, WORD W[]) para leitura do valor correspondente ao botão PRG e USER respetivamente do PIC32, este valor será zero se o botão estiver pressionado e um se não estiver pressionado. O ponteiro do valor do botão é passado como parâmetro da função, encontrando-se em W[0]. Este mecanismo encontra-se descrito no Exemplo 7.Exemplo 7 – Funções interface Switches b) Código occamPara a chamada destas funções interface a partir do código occam/occam-pi, é necessário que no programa occam sejam declarados os protótipos dasfunções de interface (ver Exemplo 8) segundo o formato padrão da TVMKRoC, ver 2.3.2.c). 28
  29. 29. Projeto Final LEETC - Programação Paralela em 2012 occam-piExemplo 8 – Biblioteca de Funções HAL do PIC32 para occam (pic32.hal)#PRAGMA EXTERNAL "PROC C.tvmspecial.5.led2.on () = 0"INLINE PROC led2.on () C.tvmspecial.5.led2.on ():#PRAGMA EXTERNAL "PROC C.tvmspecial.6.led3.on () = 0"INLINE PROC led3.on () C.tvmspecial.6.led3.on ():#PRAGMA EXTERNAL "PROC C.tvmspecial.7.led4.on () = 0"INLINE PROC led4.on () C.tvmspecial.7.led4.on ():#PRAGMA EXTERNAL "PROC C.tvmspecial.8.led2.off () = 0"INLINE PROC led2.off () C.tvmspecial.8.led2.off ():#PRAGMA EXTERNAL "PROC C.tvmspecial.9.led3.off () = 0"INLINE PROC led3.off () C.tvmspecial.9.led3.off ():#PRAGMA EXTERNAL "PROC C.tvmspecial.10.led4.off () = 0"INLINE PROC led4.off () C.tvmspecial.10.led4.off ():#PRAGMA EXTERNAL "PROC C.tvmspecial.11.led2.toggle () = 0"INLINE PROC led2.toggle () C.tvmspecial.11.led2.toggle ():#PRAGMA EXTERNAL "PROC C.tvmspecial.12.led3.toggle () = 0"INLINE PROC led3.toggle () C.tvmspecial.12.led3.toggle ():#PRAGMA EXTERNAL "PROC C.tvmspecial.13.led4.toggle () = 0"INLINE PROC led4.toggle () C.tvmspecial.13.led4.toggle ():#PRAGMA EXTERNAL "PROC C.tvmspecial.14.get.sw.prg (INT RES) = 0"INLINE PROC get.sw.prg (INT res) C.tvmspecial.14.get.sw.prg(res):#PRAGMA EXTERNAL "PROC C.tvmspecial.15.get.sw.user (INT RES) = 0"INLINE PROC get.sw.user (INT res) C.tvmspecial.15.get.sw.user(res): 29
  30. 30. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.5. Carregamento do programa occamFoi desenvolvida uma aplicação C (ver 3.5.1) de terminal em ambienteLinux que permite enviar, para o PIC32, os bytecodes do programaoccam/occam-pi já compilado (tbc), através da porta série. Já no PIC32 foiimplementada uma rotina para receber os respetivos bytecodes. 3.5.1. Programa de envioEsta aplicação foi desenvolvida em Linux por duas razões: primeiro porqueo compilador de occam/occam-pi do projeto KRoC funciona somente emambiente Linux, logo é de todo conveniente que estas duas aplicações(compiler & loader) se encontrem no mesmo ambiente; a segunda prende-se no facto de que os sistemas operativos Linux permitem uma fácil erápida utilização das portas séries, já que tratam as mesmas como sefossem ficheiros.Passando a explicar o funcionamento do programa: a) Comando de execuçãoA sintaxe de execução do programa através do terminal é a seguinte: tbc_serial_loader occam_prog.tbc /dev/serial_port_filenameEm que occam_prog.tbc são os bytecodes do programa occam, resultanteda compilação através do compilador KRoC, e serial_port_filename é onome do ficheiro da porta série onde se encontra ligado o PIC32, como porexemplo /dev/ttyACM0. b) Leitura do ficheiro tbcInicialmente o programa lê o ficheiro passado, occam_prog.tbc, e passa oseu conteúdo (bytecodes) para um array de bytes, através da funçãoread_tbc_file. c) Envio dos bytecodesO array com os bytecodes é por sua vez passado à funçãowrite_tbc_hex_file, juntamente com o seu tamanho e a localização da portasérie “/dev/serial_port_filename”, nesta função é primeiro aberta econfigurada a porta série, após configurada é primeiro enviado o tamanhodo array, e de seguida são enviados os bytecodes em blocos de 64Kbytes,este é limite máximo do buffer de input/output da porta série do PIC32.Após cada envio o programa fica a aguardar a uma resposta deacknowledge do PIC32, com o tamanho total do array de bytecodes. 3.5.2. Rotina de receção no PIC32No PIC32 para que a rotina de receção do programa occam seja executadaé necessário pressionar o botão/switch USER, e fazer o reset ao kit(pressionado o botão RESET, ou desligando e ligando o cabo USB), após istoo PIC32 vai ficar à espera que seja carregado o programa (piscando o LED2, por forma a diferenciar do LED de status do USB LED 1). 30
  31. 31. Projeto Final LEETC - Programação Paralela em 2012 occam-piNo primeiro envio a rotina recebe o tamanho do array, após isto recebe oarray em blocos de 64 bytes. 31
  32. 32. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.6. Occam-pi DemosDe entre os vários programas de teste occam-pi da máquina virtual foramescolhidos dois programas que apesar de bastantes simples espelham bemas funcionalidades da linguagem occam, e também a abstração alcançadasobre o hardware. 3.6.1. Botões e LEDsO programa 08_switch2.occ, cujo código está apresentado no Exemplo 9,divide-se em dois processos paralelos (através da diretiva PAR), o primeirodeclarado acende apenas o LED2, enquanto o segundo resume-se a umarotina de leitura do valor do botão USER, se estiver pressionado acendeapenas o LED 3, caso contrário acende somente o LED 4.Exemplo 9 – 08_switch2.occ#INCLUDE "./pic32.hal"PROC hello () INT r: SEQ r := 1 led2.off() led3.off() led4.off() PAR led2.on() WHILE TRUE SEQ get.sw.user(r) IF r = 0 SEQ led3.on() led4.off() r = 1 SEQ led3.off() led4.on() TRUE SEQ led3.on() led4.on(): 32
  33. 33. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.6.2. TimerO programa 09_delayled.occ, cujo código está apresentado no Exemplo 10,faz uso do Timer de occam para acender um LED passado 2 segundos doinício da execução e outro após 6 segundos do mesmo início, sendo estesdois processos de delay executados em paralelo.Exemplo 10 – 09_delayled.occ#INCLUDE "./pic32.hal"PROC hello () TIMER t: VAL INT delay IS 2000000:--2 sec delay VAL INT delay2 IS 6000000:--6 sec delay INT now , now2: SEQ led2.off() led3.off() PAR SEQ t ? now t ? AFTER now PLUS delay led2.on() SEQ t ? now2 t ? AFTER now2 PLUS delay2 led3.on(): 33
  34. 34. Projeto Final LEETC - Programação Paralela em 2012 occam-pi 3.7. Software DesenvolvidoTodo o software desenvolvido para a realização deste projeto encontra-seno CD que segue em anexo com este relatório. 3.7.1. Ambiente Windows XPNa diretoria, (CD)SoftwareMPLAB-WORKTVM_D32, encontra-se o projetoMPLAB, D32.mcp, compatível com o MPLAB IDE v8.63 (versões superioresnão testadas). Na mesma pasta encontram-se todos os módulos ebibliotecas C necessários para a compilação da máquina virtual, sendo oresultado o ficheiro D32.hex (ver README.txt), este é o único ficheironecessário para programar o PIC32 com a máquina virtual deoccam/occam-pi, através do programa Microship USB HID Bootloader v2.6a(versões superiores não testadas) que se encontra na pasta Microship, éimportante não alterar a disposição das diretorias.O MPLAB e o Bootloader foi utilizados no Windows XP. 3.7.2. Ambiente LinuxNa diretoria, (CD)SoftwareLinux, encontram-se duas diretoriasnecessárias para o desenvolvimento de programas occam para a máquinavirtual do PIC32. Programas occam/occam-pi a desenvolver deverão sercolocados na diretoria (CD)SoftwareLinux OCCAM.Progs, isto porque jáestá preparada para a compilação dos programas (ver README.txt),bastando executar o script de Setup para preparar o ambiente paracompilar os programas através do script kroc.A diretoria (CD)Softwaretbc_serial_loader contêm tanto o código como oexecutável, tbc_serial_loader, da aplicação para carregamento do programaoccam/occam-pi, já compilado, no PIC32 (ver README.txt).O sistema Linux utilizado deverá ter no mínimo Python 2.5.2 instalado. 34
  35. 35. Projeto Final LEETC - Programação Paralela em 2012 occam-pi4. ConclusãoO objetivo principal do projeto foi alcançado, nomeadamente, a execuçãode programas occam sobre um PIC32, com o suporte da máquina virtualimplementada.Foi também desenvolvida uma pequena biblioteca de interface para oPIC32.E por fim desenvolvido um programa para carregamento do programaoccam no PIC32.Mesmo assim, existem algumas funcionalidades da máquina virtual que nãoforam implementadas: Definição de funções da HAL para os pinos I/O doPIC32; Utilização de pinos do PIC32 para despoletar eventos no programaoccam; correção se um bug já existente na implementação KRoC da TVM,que é a gestão do time slice quando dois processos paralelos estão sempreem execução. Quanto à rotina de carregamento do programa occamtambém poderia ser melhorada, já que atualmente o programa é guardadona RAM, ou seja após reset do PIC32 é necessário carregar novamente oprograma occam.Em retrospetiva, a escolha e estudo para este projeto foi o culminar detodos os conceitos e conhecimentos adquiridos ao longo da licenciatura.Como se tratou de um projeto exploratório, para a o seu desenvolvimento eimplementação foi necessário o estudo de conceitos, e tecnologiasdesconhecidas até à altura, como a linguagem de programação paralelaoccam, programação em microcontroladores PIC32, e programação deportas série em Linux.De futuro, seria interessante completar esta implementação da máquinavirtual, e adicionar funcionalidades, como por exemplo a unidade de floatingpoint, e ainda mais interessante o protocolo de comunicação que permita aligação em paralelo de vários PIC32 executando a TVM, emulando assim porcompleto aquela que é uma das características fortes do Transputer, omulti-core. 35
  36. 36. Projeto Final LEETC - Programação Paralela em 2012 occam-pi5. Bibliografia [1] Qing Li e Carolyn Yao (2003). Real-Time Concepts for Embedded Systems. CMP Books [2] INMOS Limited (1998). occam 2, Reference Manual. Prentice Hall [3] Engº Manuel Barata (2011). Documento de Proposta do Projecto (P8). http://moodle.isel.pt/deetc/file.php/1398/LEETC- _lista_de_projectos-_Projecto_2010_2011.pdf (sitio acedido em 05/2011) [4] occam-pi. Universidade de Kent. http://www.cs.kent.ac.uk/projects/ofa/kroc/ (sitio acedido em 05/2011) [5] Transputer. Michael Brüstle http://www.transputer.net/welcome.asp (sitio acedido em 05/2011) [6] Department of Computer, Science Bucknell University (1995). Introduction to the Programming Language occam. Dr. Daniel, C. Hyde. [7] The Transterpreter Project http://www.transterpreter.org/ (sitio acedido em 05/2011) [8] Microchip Technology Inc (2008), Getting Started with PIC32 User’s Guide. [9] Microchip Technology Inc (2007), MPLAB C32 User Guide [10] Microchip Technology Inc (2008), PIC32MX3XX/4XX Family Data Sheet [11] UBW32 Schmalzhaus http://www.sparkfun.com/products/8971 (sitio acedido em 05/2011); [12] Microchip http://www.microchip.com/ (sitio acedido em 05/2011) [13] Microchip Technology Inc (2007), PIC32 Peripheral Libraries for MPLAB C32 Compiler [14] INMOS (1987), Preliminary Data IMS T800 transputer [15] INMOS Limited (1988), Transputer Insctuction Set [16] KRoC http://projects.cs.kent.ac.uk/projects/kroc/trac/ (sitio acedido em 09/2012) [17] NxOS https://github.com/danderson/nxos (sitio acedido em 09/2012) [18] LEGO Mindstorms NXT http://mindstorms.lego.com/en- us/Products/default.aspx (sitio acedido em 09/2012) [19] UBW32 firmware v1.6.3 (zip) http://www.schmalzhaus.com/UBW32/FW/UBW32_v1_6_3.X/UBW32 _v1_6_3.X.zip (sitio acedido em 09/2012) [20] David C. Wood, Computing Laboratory, University of Kent at Canterbury, KRoC — Calling C Functions from occam [21] Microchip, MPLAB IDE v8.63 (sitio acedido em 09/2012) 36

×