Microcontroladores e compressão de código. O que significa isso?

1. Microcontroladores e compressão de código. O que significa isso?

vicente
vicentte

(usa Fedora)

Enviado em 21/08/2024 - 13:59h

Boa noite.

Enquanto estudo o PIC me deparei com essa dificuldade:

No final do segundo parágrafo do item “CISC/RISC” da página 12 do PDF a baixo é afirmado: "o PIC16F84 geralmente atinge resultados de 2 para 1 na compressão de código".

"Como o PIC16F84 é um microcontrolador RISC, disso resulta que possui um número reduzido de instruções, mais
precisamente 35 (por exemplo, os microcontroladores da Intel e da Motorola têm mais de cem instruções). Todas estas
instruções são executadas num único ciclo, exceto no caso de instruções de salto e de ramificação. De acordo com o que o
seu fabricante refere, o PIC16F84 geralmente atinge resultados de 2 para 1 na compressão de código e 4 para 1 na
velocidade, em relação aos outros microcontroladores de 8 bits da sua classe."

Alguém poderia me explicar o que é essa compressão de código?

https://files.comunidades.net/mutcom/MicrocontroladorPIC16F84.pdf


  


2. Re: Microcontroladores e compressão de código. O que significa isso?

Mauriciodez
Mauriciodez

(usa Debian)

Enviado em 21/08/2024 - 16:49h


No achismo meu tanto a compressão quanto a velocidade é em relação a outros controladores da mesma classe .... logo o código compilado para esse microcontrolador ocupa a metade do espaço que ocuparia em outros e a velocidade de leitura é quatro vezes mais rápida.

Mas é só um achismo meu ... aguarde um da área para uma resposta mais exata !!!

------------------------------------------------------| Linux User #621728 |------------------------------------------------------

" Nem sempre é amigo aquele que te tira do buraco !!! ( Saddam Hussein )"

------------------------------------------------------| Linux User #621728 |------------------------------------------------------




3. Re: Microcontroladores e compressão de código. O que significa isso?

Buckminster
Buckminster

(usa Debian)

Enviado em 22/08/2024 - 18:32h

Microcontrolador: é um chip de circuito integrado único, com memória, núcleo de processador e periféricos de entrada e saída que têm o poder de serem programados. Pode ser considerado um computador pequeno. Exemplo: Arduino.
O Raspberry Pi é considerado um computador propriamente dito que contém um microcontrolador.
As arquiteturas básicas de microcontroladores podem ser RISC e CISC.
O RISC (Reduced Instruction Set Computer) tem intruções reduzidas, utiliza um conjunto de instruções simples que são executadas em um único ciclo de clock.
O CISC (Complex Instruction Set Computer) têm um grande número de instruções, que podem ser bastante complexas e capazes de realizar tarefas múltiplas em poucos ciclos, os processadores RISC têm um número menor de instruções, mais homogêneas e rápidas.

Microprocessador: tem somente um processador de tamanho pequeno em seu circuito integrado, não tem periféricos, conversores, memórias diversas, etc. Exemplo: uma GPU.

Dito isso, vamos começar pela definição, grosso modo, de compressão: como o nome já diz "compressão" é comprimir o código original para economia de processamento e memória. No caso de compressão de dados é, basicamente, para economia de espaço.
Na compressão de dados, os populares zip, rar, etc, trabalham com determinados algoritmos e em determinadas taxas (razões) de compressão.
A compressão de código trabalha com razão de compressão, não exatamente taxa de compressão como na compressão de dados, aí entram as arquiteturas dos processadores, microcontroladores, etc.

Mas veja bem, os métodos de compressão de dados não são os mesmos para compressão de código. Os algoritmos até podem ser reutilizados de um para o outro.

Por exemplo, no caso de certos tipos de microcontroladores, as palavras de códigos podem ser quebradas a fim de formar palavras de 32 bits. Os bits restantes da palavra de código quebrada são colocados na próxima palavra de 32 bits. O tamanho de uma palavra código é limitado em 16 bits. Portanto, no pior dos casos, uma palavra conterá, pelo menos, um padrão.
Em outros, as palavras de código podem ser quebradas com o objetivo de formar palavras de 16 bits, sendo o tamanho de uma palavra de código limitada a 8 bits.

Lembre que estamos falando, basicamente, de voltagens (tensões elétricas) e frequências (número de ondas elétricas por segundo) que ficam magnetizadas nas memórias, sejam elas, por exemplo, discos SD/HD (considerada memória permanente) ou RAM (memória randômica).
Um bit (0 ou 1) representa uma determinada voltagem/frequência, por exemplo - falaremos só em voltagem por economia de palavras -, uma voltagem na memória RAM de 1,27v representa um bit 1 e uma voltagem de 0,32v representa um bit 0. Isso depende de cada fabricante.
Então você tem seu código original em texto, mas quer diminuir os custos ou aumentar as funções do código, uma das maneiras é usar um algotritmo já existente, como o de Huffman.

Com relação à tua dúvida:
"o PIC16F84 geralmente atinge resultados de 2 para 1 na compressão de código e 4 para 1 na velocidade, em relação aos outros microcontroladores de 8 bits da sua classe."

O PIC16F84 possui, basicamente, 68 bytes de memória RAM, 64 bytes de EEPROM e um timer de 8 bits, por isso é considerado de classe de 8 bits, então, provavelmente, ele terá um tamanho padrão de uma palavra de código limitada a 8 bits.
2 para 1 é a taxa de compressão.
Os microcontroladores já saem prontos de fábrica, vamos por dizer assim, com essas taxas de compressão, dependendo da arquitetura, como eu falei antes. Então eles já saem prontos para comprimir o código ao programar-se para microcontroladores.
Os desenvolvedores de microcontroladores que tem de saber disso tudo; os programadores de, por exemplo, Arduino, não se faz muito necessário, mas, como se diz, conhecimento não ocupa espaço.

Compressão de código, nesse sentido, nada mais é do que lidar com endereçamentos nas e das memórias RAM com índices, basicamente, e o microcontrolador já sai pronto de fábrica, na maioria das vezes.
Depois tem também a descompressão.

Aliás, de um modo geral, compressão (tanto de dados como de código) podemos dizer que é semelhante a um índice de um livro onde o microcontrolador economiza tempo para encontrar determinado dado ou código, mas o índice está separado do livro, no caso o índice está na RAM e os dados no SD/HD. Na compressão de código, fica na RAM e na EEPROM.

O Arduino, por exemplo, tem bibliotecas de compressão específicas para cada caso: Shox96 Progmem Compression, Polyline, etc, mas que não são compressão de código propriamente dita para microcontroladores uma vez que trabalham com funções específicas e não saem embutidas de fábrica, mas dão uma boa idéia.

Não sei se me fiz claro, porque tem muito mais coisas como o clock, qualidade do material empregado (ouro, cobre, etc), mas acredito que deu para entender.
O Maurício resumiu bem quanto ao resultado.


https://ic.unicamp.br/~pannain/pub/pub/tese.pdf
https://sweet.ua.pt/jpa/Downloads_files/ArtigoE&T_21394_21540.pdf
https://www.arduino.cc/reference/pt/language/functions/analog-io/analogread/


_________________________________________________________
Always listen the Buck!
Enquanto o cursor estiver pulsando, há vida!


4. Re: Microcontroladores e compressão de código. O que significa isso?

vicente
vicentte

(usa Fedora)

Enviado em 23/08/2024 - 10:05h

Grato pela disposição em me ajudar.

Acho que entendi sim. A compressão de código pelo PIC é realizado por circuitos de portas lógicas combinadas, nesse caso muito provavelmente um decodificador lógico projetado e dedicado a esse fim. Por favor me corrija se eu estiver errado. Afinal estou estudando então é a minha chance de aprender o certo.

Isso me leva à quatro indagações:

I - Essa compressão é na verdade uma forma de tradução de um padrão de constituição de uma instrução para outro, sendo portanto esse termo "compressão" usado apenas para transmitir a ideia de "simplificação" com uma consequente redução do tamanho da palavra da instrução? Como vc mesmo disse a ideia de "compressão" para instruções não é a mesma para dados. Se puder peço por favor que explique melhor esses dois conceitos de compressão de dados e compressão de instruções.

II - A compressão é realizada no momento em que os dados são gravados na memória FLASH, ou só no momento que vai carregar para o Pipeline (registradores) (com o PIC em operação)?

III - A ULA só processa as instruções com o código ""comprimido""?

IV - Após a execução da instrução o resultado precisa ser novamente traduzido para sua forma complexa novamente?

Eu tive o cuidado de estudar eletrônica digital antes como base para adentrar no estudo dos microcontroladores e por isso minhas perguntas são referentes a tão baixo nível. Pretendo atuar na área de projetos de equipamentos onde a programação é parte do domínio da área mas não o objetivo central. Eu gosto muito dessa parte de interação entre hardware e software. Projetar e construir máquinas autônomas e desenvolver seus firmwares eu mesmo.

Assim que eu tiver feito várias experiências e projetos por minha própria conta em casa na minha mesa e em fim dominar todo esse conhecimento aí verei como transformar esse hobby numa profissão. Ou, tornar meu hobby também a minha profissão. "Trabalhe com o que você ama e nunca mais precisará trabalhar na vida." - Confúcio


5. Re: Microcontroladores e compressão de código. O que significa isso?

Buckminster
Buckminster

(usa Debian)

Enviado em 23/08/2024 - 18:23h

Vamos lá!
I-
Veja aqui (não gosto muito de usar wikipédia), mas está correto:
https://pt.wikipedia.org/wiki/Codifica%C3%A7%C3%A3o_de_Huffman
Veja principalmente na parte Compressão:
"Para ilustrar o funcionamento do método, vamos comprimir a sequência de caracteres AAAAAABBBBBCCCCDDDEEF.", veja a tabela de Caractere e Código.
Vira uma espécie de índice.
E na Descompressão simplesmente se traduz a palavra-código de volta para os caracteres.

Levando-se em conta que, basicamente, tudo são dados em desenvolvimento/programação, então a compressão de dados e de código basicamente é a mesma. Como eu falei antes, diferem no método, ou seja, no caso de microcontroladores a compressão de código é como você mesmo disse: "usada apenas para transmitir a ideia de "simplificação" com uma consequente redução do tamanho da palavra da instrução".

RISC são arquitetura Harvard. Na arquitetura Harvard observamos dois barramentos distintos: um para acessar a memória de dados (RAM) e outro para acessar a memória de programas (OTP, FLASH, EPROM, EEPROM).
A compressão de dados se dará na memória de dados e a compressão de código se dará na memória de programas o que facilita a operação dos circuitos de entrada e saída, mas usam barramentos diferentes, ou seja, circuitos de entrada e saída separados:
https://raa.pro.br/wp-content/uploads/2022/04/Microprocessadores-Microcontroladores_Aula_1_Noturno.p...

Na arquitetura Von Neuman também existe a separação entre memória de dados e de programa, mas há apenas um barramento de dados e endereços saindo da CPU. Lembrando que "barramento", fisicamente falando, é geralmente um conjunto de fios de cobre.
Sabemos que arquitetura Von Neuman (CISC) são os processadores comumente usados, Intel i7, i9, etc; AMD Ryzen, etc, então, nesses, só é possível a compressão de dados, pois, basicamente, não é possível programá-los como os microcontroladores (RISC). Contudo, vários CISC já saem com o código de instruções básicas comprimido de fábrica.
Grosso modo, o desempenho de um processador para outro passa por essa descompressão/leitura e velocidade do clock.
Por exemplo, devido à separação entre dados e programa, um processador da arquitetura Harvard (RISC) executará um programa em menor tempo do que um processador da arquitetura Von Neuman (CISC) de mesmo clock.
Basicamente, um RISC é programável, um CISC não é.

Para melhor entendimento, leia abaixo a partir do Capítulo 4, página 42, e depois leia tudo:
https://ic.unicamp.br/~pannain/pub/pub/tese.pdf

II-
Em microcontroladores, o código é comprimido na fábrica e armazenado na memória de programa/instruções (ROM's, FLASH's ou EPROM's ou EEPROM's) onde é descomprimido e armazenado na memória cache de instrução, caso tiver, senão é carregado diretamente para os registradores e para a ULA (lembrando que a ULA opera em conexão direta com os registradores).
Porém, depende do microcontrolador.
Um arquivo de texto que contenha um programa em Assembly ou C, C++, etc, é o código original, daí você pode compilá-lo e depois comprimí-lo para reduzir o binário. Este código deve ser processado por uma ferramenta em software que divide o código executável em pequenos trechos chamados de blocos de compressão. Esses trechos são comprimidos usando geralmente o código de Huffman, um algoritmo de compressão sem perda, que codifica caracteres mais frequentes em sequências menores de bits para gravar no microcontrolador.
Aí entra o algoritmo de compressão e depois o de descompressão, o método utilizado, etc.

Caso seja esse teu interesse, fazer teus próprios códigos já comprimidos, veja explicações e exemplos aqui:
https://medium.com/@davidsonbrsilva/compress%C3%A3o-de-dados-pelo-algoritmo-de-huffman-5e04bc437d77

e aqui:
https://www.ime.usp.br/~pf/estruturas-de-dados/aulas/huffman.html

Pois não tenho como explicar isso de forma simples porque envolve desenvolvimento/programação.

III-
A ULA processa o código descomprimido.

IV-
Não, geralmente o código comprimido é gravado na memória, são as intruções do microcontrolador e é descomprimido para leitura.
Não tem necessidade de fazer esse jogo compressão/descompressão/compressão cada vez que for processar o código, a não ser que tu tenha um PIC com um hardware poderoso.

Lembrando que tem memória ROM, OTP (PROM), EPROM, EEPROM e FLASH.

Lembrando que nem todo microcontrolador tem código comprimido, pois depende do programa, das funções, do tamanho das linhas de código, etc.
A criação de programas para microcontroladores é significativamente diferente da criação de programas para PCs.
Firmwares, drivers, etc, geralmente são feitos em Assembly e/ou C, mas podem ser feitos em outras linguagens, porém, em Assembly sozinho ou misturado com C, a rapidez de execução não se compara com nenhuma outra linguagem. A questão é que código em Assembly é extenso, pois aceita somente um comando por linha, porém, por ser linguagem de baixo nível a sua execução pode chegar a 50 vezes mais rápida do que qualquer outra linguagem.
A programação em si de fimwares é tranquila, a questão é o conhecimento que isso envolve, é demorado, pois tem várias marcas e modelos de hardwares.

Não sei se ficou bem claro, pois faz um bom tempo que estou afastado desse tipo de desenvolvimento/programação e, pelo que vi, as informações são escassas.
As ferramentas (IDEs), gravadores, simuladores, etc, para programação PIC você pode encontrar no Google, mas acredito que você já tenha, por isso não vou sugerir.
Caso cometi algum erro, releve, pois várias coisas nesse textão fiz de cabeça e alguns links tive que verificar se ainda estavam ativos.

Deixo aqui uns links para estudo:
https://professor.luzerna.ifc.edu.br/ricardo-kerschbaumer/wp-content/uploads/sites/43/2018/02/Aposti...

Aqui tem sobre PIC:
https://pellisonblog.wordpress.com/wp-content/uploads/2018/08/2-microncontroladores-saladeaula.pdf
https://www.microchip.com/en-us/product/PIC16F877

https://ic.unicamp.br/~ducatte/mo401/1s2011/T2/Apresentacoes/G13-096149-ap.pdf

https://www.ime.usp.br/~pf/estruturas-de-dados/aulas/huffman.html


_________________________________________________________
Always listen the Buck!
Enquanto o cursor estiver pulsando, há vida!






Patrocínio

Site hospedado pelo provedor RedeHost.
Linux banner

Destaques

Artigos

Dicas

Tópicos

Top 10 do mês

Scripts