DEV Community: Matheus Gomes

Dia 24~26 - Gestão de Tarefas (Sistema Operacional)

Matheus Gomes — Thu, 24 Oct 2024 22:38:50 +0000

Esses dias estive quebrando a cabeça para implementar gestão de tarefas utilizando contexto. Código aqui.

Como tudo nesse projeto, essa foi mais uma "task" do conteúdo do professor Maziero.

Sobre a implementação:

Foi implementado um sistema de gerenciamento de tarefas usando contextos do sistema. Ele gerencia tarefas cooperativas executando uma tarefa até passar explicitamente para outra.

Estrutura task_t: Representa uma tarefa, armazenando o contexto de execução, um identificador (ID), e ponteiros para facilitar a construção de uma fila duplamente encadeada de tarefas.

typedef struct task_t
{
  struct task_t *prev, *next; // ponteiros para usar em filas
  int id;                     // identificador da tarefa
  ucontext_t context;         // contexto armazenado da tarefa
  short status;               // pronta, rodando, suspensa, ...
  // ... (outros campos serão adicionados mais tarde)
} task_t;

Inicialização: A função ppos_init() é chamada para configurar o contexto principal do programa. Isso prepara o sistema para gerenciar múltiplas tarefas.

Criação de tarefas: Novas tarefas são criadas com task_init(), onde você passa uma função e argumentos para ser executada dentro da nova tarefa. Essas tarefas recebem um novo contexto e pilha, e o ID da tarefa é atualizado.

Mudança de contexto: A função task_switch() permite alternar entre tarefas, trocando o contexto atual pelo de uma tarefa especificada.

Finalização de tarefa: Uma tarefa pode encerrar sua execução e retornar ao contexto principal com task_exit().

Dia 23 - Configurando o NixOS para utilizar o debbuger de C no VSCode

Matheus Gomes — Tue, 22 Oct 2024 01:46:01 +0000

Eu instalo meus pacotes todos em environment.systemPackages no /etc/nixos/configuration.nix.

Então, além do gcc, para utilizar o debbuger é necessário:

environment.systemPackages = with pkgs; [
...
vscode-fhs
gdb
]

Utilizar o vscode-fhs facilita muito o trabalho, instalar o pacote vscode (sem o fhs) gera alguns transtornos. Mais informações aqui.

No vscode, instale essa extensão:

Para maior confiabilidade, "forcei" a criação de paths com:

environment.variables.PATH = "${lib.makeBinPath [
pkgs.gdb
pkgs.gcc_multi // esse é o pacote que utilizo pro gcc
]}:$PATH";

Não esqueça de reiniciar o computador após o sudo nixos-rebuild switch

Dentro do projeto, crie uma pasta .vscode e adicione um arquivo launch.json e tasks.json

tasks.json:

{
  "tasks": [
    {
      "type": "cppbuild",
      "label": "C/C++: gcc arquivo de build ativo",
      "command": "/nix/store/2ap4rlj55kw8q5ndycl0r8w312ggpf1c-gcc-wrapper-13.2.0/bin/gcc",
      "args": [
        "-fdiagnostics-color=always",
        "-g",
        "${file}",
        "-o",
        "${fileDirname}/${fileBasenameNoExtension}"
      ],
      "options": {
        "cwd": "${fileDirname}"
      },
      "problemMatcher": [
        "$gcc"
      ],
      "group": {
        "kind": "build",
        "isDefault": true
      },
      "detail": "Tarefa gerada pelo Depurador."
    }
  ],
  "version": "2.0.0"
}

launch.json:

{
  "version": "0.2.0",
  "configurations": [
    {
      "name": "Debug arquivo ativo",
      "type": "cppdbg",
      "request": "launch",
      "program": "${fileDirname}/${fileBasenameNoExtension}",
      "args": [],
      "cwd": "${fileDirname}",
      "environment": [],
      "externalConsole": false,
      "MIMode": "gdb",
      "setupCommands": [
        {
          "description": "Enable pretty-printing for gdb",
          "text": "-enable-pretty-printing",
          "ignoreFailures": true
        }
      ],
      "miDebuggerPath": "/nix/store/2ap4rlj55kw8q5nd2460r8w312ggpf1c-gdb-14.2/bin/gdb",  
      "preLaunchTask": "C/C++: gcc arquivo de build ativo",
      "internalConsoleOptions": "openOnSessionStart"
    }
  ]
}

Para o campo command do tasks.json utilize o comando which gcc para pegar o caminho.
Faça o mesmo para miDebuggerPath do launch.json com o comando which gdb

Entre no arquivo que deseja depurar e aperte F5:

Depure e seja feliz.

Dia 21 e 22 - Entendendo contextos em C

Matheus Gomes — Sun, 20 Oct 2024 23:20:19 +0000

Em C, contexto é o estado atual de execução de um programa, incluindo registradores (pequenas áreas de armazenamento dentro da CPU, usadas para armazenar dados e instruções durante a execução de programas), variáveis e o fluxo de instruções, crucial para trocar tarefas.

Troca de contextos para sistemas operacionais

A principal função é permitir a multitarefa. Isso garante que o sistema possa alternar entre processos de forma eficiente.

Aqui foi disponibilizado o arquivo contexts.c. É um demonstrativo de como contextos funcionam.

Logo no topo desse arquivo, percebemos a importação da biblioteca ucontext.h. Ela permite manipular o contexto de execução.

No trecho abaixo vemos que são criados 3 contextos, e esses 3 contextos terão a memória alocada do tamanho de STACKSIZE.

#define STACKSIZE 64 * 1024 /* tamanho de pilha das threads */

ucontext_t ContextPing, ContextPong, ContextMain;

E logo depois, as funções Ping e Pong que serão executadas em seus respectivos contextos:

void BodyPing(void *arg)
{
  int i;

  printf("%s: inicio\n", (char *)arg);

  for (i = 0; i < 4; i++)
  {
    printf("%s: %d\n", (char *)arg, i);
    swapcontext(&ContextPing, &ContextPong);
  }
  printf("%s: fim\n", (char *)arg);

  swapcontext(&ContextPing, &ContextMain);
}

/*****************************************************/

void BodyPong(void *arg)
{
  int i;

  printf("%s: inicio\n", (char *)arg);

  for (i = 0; i < 4; i++)
  {
    printf("%s: %d\n", (char *)arg, i);
    swapcontext(&ContextPong, &ContextPing);
  }
  printf("%s: fim\n", (char *)arg);

  swapcontext(&ContextPong, &ContextMain);
}

/*****************************************************/

Na função main, é utilizado malloc para reservar as stacks, onde posteriormente são atribuidos com uc_stack.ss_sp ao contexto, e swapcontext é usado para alternar entre eles.

int main(int argc, char *argv[])
{
  char *stack;

  printf("main: inicio\n");

  getcontext(&ContextPing);

  stack = malloc(STACKSIZE);
  if (stack)
  {
    ContextPing.uc_stack.ss_sp = stack;
    ContextPing.uc_stack.ss_size = STACKSIZE;
    ContextPing.uc_stack.ss_flags = 0;
    ContextPing.uc_link = 0;
  }
  else
  {
    perror("Erro na criação da pilha: ");
    exit(1);
  }

  makecontext(&ContextPing, (void *)(*BodyPing), 1, "    Ping");

  getcontext(&ContextPong);

  stack = malloc(STACKSIZE);
  if (stack)
  {
    ContextPong.uc_stack.ss_sp = stack;
    ContextPong.uc_stack.ss_size = STACKSIZE;
    ContextPong.uc_stack.ss_flags = 0;
    ContextPong.uc_link = 0;
  }
  else
  {
    perror("Erro na criação da pilha: ");
    exit(1);
  }

  makecontext(&ContextPong, (void *)(*BodyPong), 1, "        Pong");

  swapcontext(&ContextMain, &ContextPing);
  swapcontext(&ContextMain, &ContextPong);

  printf("main: fim\n");

  exit(0);
}

Output do programa executado:

main: inicio
    Ping: inicio
    Ping: 0
        Pong: inicio
        Pong: 0
    Ping: 1
        Pong: 1
    Ping: 2
        Pong: 2
    Ping: 3
        Pong: 3
    Ping: fim
        Pong: fim
main: fim

Com isso, podemos perceber que mesmo alterando os contextos, os valores que "fluem" pela função são mantidos, um exemplo nesse caso é o índice do for.

Você deve ter percebido que existe um malloc para o contexto de Ping e de Pong, mas vemos que existe um contexto para main também, por qual motivo não existe um malloc para ele?

O ContextMain não precisa de uma stack separada porque ele opera na stack do thread principal, enquanto os contextos Ping e Pong têm suas próprias stacks alocadas dinamicamente.

Se crio um contexto e não aloco memória para ele, quando utilizamos o swap, ele vai para a stack principal do programa.

Esse código é do professor Maziero, encontrado no sub-projeto desenvolvido do PingPongOS "Trocas de Contexto".

Dia 20 - Reimplementando lista circular duplamente encadeada

Matheus Gomes — Sat, 19 Oct 2024 15:14:13 +0000

Fiz alguns ajustes na versão incial da minha lista, agora ela atende os requisitos dispostos no material do professor Maziero. Ajustei para passar os testes, e também resolvi utilizar readaptar para C. A compilação juntamente com o arquivo de teste disponibilizado me pareceu menos problemática desse modo.

Revisitando o código dessa lista, precisei revisitar listas mais simples que vem antes da circular duplamente encadeada, assim consegui montar um raciocínio sólido na hora de codificar.

Lista duplamente encadeada

É uma estrutura na qual cada nó contém três partes: Valor, ponteiro para o próximo nó, e ponteiro para o nó anterior.

Permite navegação bidirecional, e para remover ou adicionar um nó, é necessário somente ajustar os ponteitos do nó anterior e do nó seguinte.

[head] <-> [nó1] <-> [nó2] <-> [tail]

Lista circular

Pode ser simplesmente encadeada (sentido unilateral) ou duplamente encadeada (esse é o que estou usando para o projeto).
O último nó da lista está conectado ao primeiro, o que faz com que a lista não tenha um ponto de término natural.
A lista pode ser percorrida indefinidamente, pois ao chegar no final, ela retorna ao início.

Lista circular duplamente encadeada e sua relação com sistemas operacionais

Utilizar uma lista circular duplamente encadeada, faz com que o sistema operacional tenha caracterísica de escalonamento circular.

Dito isso, após o último processo ser executado, o sistema retorna ao primeiro e continua a execução.

Imaginando que um sistema operacional possui três processos:

[P1] <-> [P2] <-> [P3] <-> [P1] ...

Após o P3 terminar seu tempo de execução, a lista voltará diretamente para P1, garantindo uma execução contínua.

O código atual do sistema operacional pode ser encontrado aqui.

Dia 19 - Retornando a criação do meu sistema operacional

Matheus Gomes — Fri, 18 Oct 2024 01:33:06 +0000

Hoje está sendo um dia de difícil assimilação para conteúdos escritos então resolvi consumir alguns conteúdos mais práticos sobre sistemas operacionais.

O Waine há alguns conteúdos para membros de sistema operacional baseado na literatura do Professor Maziero.

O conteúdo é voltado para embarcados utilizando a linguagem Zig e C. Mas tentarei ir adaptando pro meu sistema operacional feito em C++. (talvez eu me renda e faça em zig e C também)

Com essa decisão, me livrei do Windows, e agora estou utilizando vscode + NixOS para codar em C++.

NixOS é uma distribuição Linux com configuração declarativa, baseada no gerenciador de pacotes Nix, que oferece ambientes reprodutíveis, reversíveis e altamente controlados.

Esse vídeo do DioLinux fala um pouco sobre:

A instalação de tudo é extremamente simples e dificilmente dá problema, e se der, você pode retornar a versões mais antigas do seu sistema operacional.

Os próximos dias serão voltados a série de vídeos do Waine e ao Inglês, eventualmente retornarei ao livro.

Dia 17 e 18 - Recalibrando meu GPS

Matheus Gomes — Wed, 16 Oct 2024 22:08:19 +0000

Esses dias tenho estado com a internet ruim, então pausei a leitura e outras coisas para me reorganizar.

Certa vez escutei uma frase: "O caminho que trilhamos precisa ser frequentemente recalibrado, como se fosse um GPS."

Então estou usando esses dias para relembrar meus objetivos e como vou fazer para alcançá-los.

Me dei conta que minha jornada à física computacional é composta por "subjornadas":
Há a jornada da computação, da matemática e física, do inglês e do desenvolvimento pessoal.

As que tenho mais investido atualmente é a da computação e do desenvolvimento pessoal, porém, percebi que algumas(talvez várias) oportunidades estão passando por não saber inglês.

Então, vai ser mais um ponto que irei focar.

Com relação as "outras jornadas", pretendo terminar o livro referente a computação que tenho colocado resumos aqui, e continuar cuidando de mim e da minha saúde (mudei alguns hábitos alimentícios, intensifiquei os treinos na academia e dei uns ajustes no visual).

Com essa jornada eu tenho percebido que eu tenho sido frequentemente testado. Desde que comecei, sempre acontece alguma coisinha que interfere diretamente na rotina, dessa vez foi a internet com problemas.

Creio que esses "testes do universo" faz parte do jogo, e gosto disso. Parece que tem frequentemente alguém falando: "Você não quer? Dá teu jeito".

Isso me lembra um trecho de João, capítulo 5, versículos 8 a 10 (Eu não sou nem um pouco religioso, mas algumas coisas quando se destacam temos que dar a devida atenção):

Então, Jesus lhe disse: ― Levante‑se! Pegue a sua maca e ande. Imediatamente, o homem ficou curado, pegou a maca e começou a andar.

Engole o choro e segue 😅.

Então é isso, continuarei lendo o livro sobre computação, quero terminar ele logo para voltar a codar em C/C++ e fazer meu sistema operacional. Terminando isso vou começar minha jornada na física/matemática.

Esse livro vai ser um looooongo caminho, fiz uma estimativa, se eu ler uma seção por dia, demoraria mais de 100 dias para terminar. Devagar e sempre, não tem ninguém com pressa 🐢.

MAS!!! Inglês eu vou dar uma atenção especial, pois já posso fazer proveito dele no momento que vivo. Vou tentando trazer algo aqui durante as seções dos livros de computação.

Seguimos!

Dia 16 - 1.6 Desempenho - Parte 1

Matheus Gomes — Tue, 15 Oct 2024 03:06:32 +0000

Esse post fala sobre o capítulo 1.6 do livro "Organização e Projeto de Computadores: Interface Hardware/Software"

Definindo desempenho

Na computação há duas medidas de desempenho: largura de banda e tempo de execução.

Tempo de execução: Tempo total exigido para o computador completar uma tarefa.

Largura de banda: Número de tarefas completadas por unidade de tempo.

Tomar medidas para reduzir o tempo de resposta, quase sempre melhora a largura de banda. (por exemplo, trocar o processador por uma versão mais rápida) Essa medida é categorizada como escalonamento vertical.

Aumentar a quantidade de processadores normalmente só melhora a largura de banda, porém, se o processamento for tão grande quanto a largura da banda, o tempo de resposta também é melhorado, pois diminuiria tempo de espera de tarefas enfileiradas. Essa medida é categorizada como escalonamento horizontal.

Relacionando desempenho e tempo de execução

Comparando dois computadores:
Se computador A executa um programa em 30 segundos, e B em 60, o quanto A é mais rápido que B?

6030=2\frac{60}{30} = 2

A é 2 vezes mais rápido que B. Ou seja, B é 2 vezes mais lento que A.

Então:

A2=B\frac{A}{2} = B

Medindo desempenho

O tempo é a principal medida de desempenho do computador. Mas há distinção entre o tempo decorrido e o tempo que o processador está trabalhando em nosso favor.

O tempo de CPU é o tempo real que a CPU gasta para uma tarefa específica, podendo ser separado em:

Tempo de CPU do usuário: tempo gasto de CPU em um programa.

Tempo de CPU do sistema: tempo gasto do sistema operacional realizando tarefas em favor do programa.

"Para melhorar o desempenho de um programa, deve-se ter uma definição clara de qual é a métrica de desempenho de interesse."

Desempenho da CPU e seus fatores

Ciclo de clock: Tempo para um periodo de clock do processador que trabalha em uma taxa constante.

Período de clock: Extensão de cada ciclo de clock.

Para calcular o tempo de execução da CPU:

Então, para melhorar o desempenho é necessário reduzir o número de ciclos de clocks, ou o tamanho do ciclo do clock.

Por exemplo, temos um computador A que executa um programa em 10 segundos. O clock dele é de 2 GHz. E queremos montar um computador B que execute esse programa em 6 segundos, o computador B exigirá 1,2 vezes a quantidade de ciclos de clock do computador A. Precisamos achar que taxa de clock o computador B deve ter.

Computador A:
2 GHz == 2x10⁹
a == ciclos de clock de CPU

\frac{a}{2x10⁹}

a = 10 x 2 x 10⁹ = 20 x 10⁹ c i c l os

Computador B:
b == taxa de clock

\frac{1,2x20x10⁹}{b}

\frac{1,2x20x10⁹}{6}

\frac{0,2x20x10⁹}{1}

\frac{4x10⁹}{1} = 4GHz

Dia 15 - 1.5 Tecnologias para construção de processadores e memórias

Matheus Gomes — Mon, 14 Oct 2024 00:19:33 +0000

Esse post fala sobre o capítulo 1.5 do livro "Organização e Projeto de Computadores: Interface Hardware/Software"

Um transistor é uma chave liga/desliga controlada por eletricidade (é aqui que o binário que vimos na seção 1.3 começa a fazer sentido). E o circuito integrado é a combinação de vários transistores em um único chip. a Lei de Moore que vimos na seção 1.2 é prevista na taxa de crescimento do número de transistores por chip. E isso também explica o motivo de a Lei de Moore estar desacelerando nos últimos anos (limitação física).

Um circuito com centenas de milhares de transistores se chama VLSI (Very-large-scale integration).

Desde 1977 a capacidade de transistores por chip de DRAM aumentou em mais de 16.000 vezes.

O restante da seção se prolonga sobre como são fabricados os circuitos integrados e como seu custo é fundamental para projetistas de computador. E bom, hoje é domingo e esse trecho honestamente não me interessou. Nos vemos na próxima seção do livro. 😅

Dia 14 - 1.4 Sob as tampas

Matheus Gomes — Sun, 13 Oct 2024 00:37:26 +0000

Esse post fala sobre o capítulo 1.4 do livro "Organização e Projeto de Computadores: Interface Hardware/Software"

"O hardware de qualquer computador realiza as mesmas funções básicas: entrada, saída, processamento e armazenamento de dados."

Com essa frase, iniciamos o principal tema do livro: Como essas funções são realizadas.

Os cinco componentes do computador:

São eles: entrada, saída, memória, caminho de dados e controle.

"O processador obtém instruções e dados da memória. A entrada escreve dados na memória e a saída lê os dados desta. O controle envia os sinais que determinam as operações do caminho de dados, da memória, da entrada e da saída."

O restante do capítulo se prolonga em como os hardwares funcionam baseados na definição acima. Desde monitores até circuitos integrados.

Arquitetura do conjunto de instruções

É uma abstração que inclui tudo que os programadores precisam saber para fazer um programa em linguagem de máquina binária funcionar corretamente (um exemplo é a arquitetura x86, desenvolvida pela Intel, e amplamente usada).

O sistema operacional geralmente guarda os detalhes das funções de baixo nível do sistema para que os programadores de aplicações não precisem se preocupar com esses detalhes.

A junção do conjunto de instruções e da interface do sistema operacional é chamada de interface binária de aplicação (ABI). (Define um padrão para a portabilidade binária entre computadores).

Conceitos de memória:

Memória volátil: Conserva os dados apenas quando há alimentação de energia.
Memória não volátil: Os dados são conservados mesmo com ausência de energia.

Memória principal: É usada para armazenar programas enquanto estão sendo executados (DRAM).
Memória secundária: Memória não volátil usada para armazenar programas e dados entre execuções. (por ex. HDD).

### Comunicação entre computadores
As redes constituem o backbone dos sistemas de computação atual.

Vantagens

Comunicação: Informações trocadas em alta velocidade entre computadores.
Compartilhamento de recursos: Os dispositivos I/O podem ser compartilhados pelos computadores que compõem a rede.
Acesso remoto: Conexão a computadores por meio de longas dintâncias.

Por fim, o capítulo finaliza com o seguinte desafio:

A memória semicondutora DRAM, a memória flash e o armazenamento de
disco diferem significativamente. Para cada tecnologia, descreva a principal diferença quanto a cada um dos seguintes aspectos: volatilidade, tempo de acesso relativo aproximado e custo relativo aproximado em comparação com a DRAM.

Em resumo, DRAM é volátil, então, perde dados quando não há energia. Seu tempo de acesso é rápido e o custo, nesse caso, serve como base de comparação (considerado médio). A memória flash é não volátil mas seu tempo de acesso é mais lento que o da DRAM, com um custo mais barato. O armazenamento em disco também é não volátil, possui um tempo de acesso muito mais lento que a DRAM e mais lento que a memoria em flash, e seu custo é o mais barato.

Dia 13 - 1.3 Por trás do programa

Matheus Gomes — Sat, 12 Oct 2024 02:05:47 +0000

Esse post fala sobre o capítulo 1.3 do livro "Organização e Projeto de Computadores: Interface Hardware/Software"

O começo desse capítulo deixa explícito que o computador só pode executar instruções de baixo nível e há várias camadas que interpretam ou traduzem as operações de alto nível para baixo nível. Esse é um grande exemplo de abstração.

Essas camadas demonstram a organização de maneira hierárquica. software de sistemas seria serviços como: sistemas operacionais, compiladores, carregadores e montadores.

Software de aplicações é o que nós, devs, normalmente codamos muito: apps de web, desktop e afins.

Há muitos software de sistemas, mas os mais fundamentais são: sistemas operacionais e compiladores.

Um ponto interessante é que, no contexto desse livro, C/C++ é considerado linguagem de alto nível. Já vi algumas pessoas falando isso também, e faz sentido, mas quando comparado com Python por exemplo, eu também acho que faz sentido chamar C/C++ de baixo nível. Será que cabe perspectiva nessa "discussão"? Honestamente não ligo muito para essa terminologia 😅.

Continuando, sistema operacional é importante por conta da manipulação de operações básicas de entradas e saídas, alocamento de memória, além de ser o caminho de comunicação amigável entre o usuário e o hardware. Já o compilador é responsável por traduzir linguagens de alto nível para instruções de máquina.

Sobre instruções de máquina:

Nossas instruções são grupos de bits que o computador entende e obecede. Nada mais são que sinais elétricos resumidos em 0's e 1's.

Gostaria de fazer uma menção honrosa ao excelente jogo "Turing Complete" isso é bastante demonstrado lá.

Sobre montador (assembler):

Um assembler traduz a versão simbólica de uma instrução para binário.

add A,B

seria traduzido para:

1000110010100000

Essa instrução diz para o computador somar dois números A e B. E essa linguagem simbólica foi denominada como assembly.

Também existem linguagens que ignoram essa etapa intermediária já traduzindo diretamente para linguagem de máquina. Um exemplo é o GoLang, que após utilizamos o go build, é gerado um executável binário.

Então, por que não codamos em binário e assembly?

Utilizar linguagens de alto nível:

Permite que o programador pense em uma linguagem mais natural, e também há linguagens projetadas para fins específicos.
Aumento de produtividade.
Permite que os programas sejam independentes do computador no qual estão sendo desenvolvidos. Compiladores e Montadores traduzem o programa para instruções binárias de qualquer máquina.

Dia 12 - 1.2 Oito grandes ideias sobre arquitetura de computadores

Matheus Gomes — Fri, 11 Oct 2024 00:03:17 +0000

Esse post fala sobre o capítulo 1.2 do livro "Organização e Projeto de Computadores: Interface Hardware/Software"

1 - Projete pensando na "Lei de Moore"

Lei de Moore é uma observação feita por Gordon Moore, cofundador da Intel, em 1965. Essa lei declara que os recursos do circuito integrado dobram a cada 18 a 24 meses. O livro nesse trecho alega: Como projetos de computador podem durar anos, os recursos disponíveis por chip podem facilmente dobrar ou quadruplicar entre o inicio e o final do projeto, então o ideal, é que antecipemos onde a tecnologia estará quando terminarmos o projeto.

Fazendo algumas pesquisas, achei uma matéria no Terra explicando que a Lei de Moore está desacelerando, pois os desafios físicos e de engenharia estão tornando cada vez mais difícil manter o ritmo de miniaturização dos transistores.

2 - Use a abstração para simplificar o projeto

Nesse trecho é dito como tivemos que inventar técnicas para nos tornar mais produtivos, se não, o tempo de projeto aumentaria de modo insustentável quando os recursos aumentassem pela Lei de Moore. Então, uma técnica de produtividade é a abstração, os detalhes de baixo nível são ocultados, enquanto oferece um modelo mais simples de alto nível. (Um exemplo para melhor entendimento, são as infinitas bibliotecas em Python escritas em C.)

3 - Torne o caso comum veloz

"Tornar o caso comum veloz costuma melhorar mais o desempenho do que otimizar o caso raro."
O caso comum é mais fácil de melhorar. Por ser comum, ele é mais simples. Saber o que é o "caso comum" será ensinado seções mais a frente no livro.

4 - Desempenho pelo paralelismo

Esse conceito também será aprofundado ao decorrer do livro, mas basicamente consiste em mais desempenho realizando operações em paralelo.

5 - Desempenho pelo pipelining

É um padrão de paralelismo. Darei um exemplo:
Imagine uma fábrica de carros com 5 estágios:

Chassis montado.
Motor instalado.
Pintura aplicada.
Interior montado.
Teste realizado.

Se a fábrica não utilizar pipelining, cada carro terá que passar por todos os cinco estágios antes que o próximo carro comece. Se cada estágio demorar uma hora, para montar o primeiro carro vai demorar cinco. Para otimizar isso, após o primeiro carro terminar o estágio um, será adicionado outro carro nesse estágio, enquanto o primeiro carro segue a pipeline, e assim funcionará sucessivamente.

6 - Desempenho pela predição

Esse é um conceito que honestamente não consegui entender pela definição do livro, então busquei outras fontes:

Um exemplo é a predição de desvio, técnica usada em processadores para melhorar o desempenho ao prever o caminho que o código seguirá em instruções condicionais (if, switch). Em vez de esperar pela avaliação da condição, o processador faz uma previsão e continua executando instruções antecipadamente. Se a previsão estiver correta, o desempenho melhora porque o processador não fica ocioso. Se errada, ele apenas descarta as instruções incorretas. Isso reduz o tempo ocioso e aumenta a eficiência do sistema, especialmente em loops e condições frequentes.

7 - Hierarquia de memórias

É um conceito que organiza diferentes tipos de memórias de um sistema em níveis com diferentes velocidades e capacidades. Utilizando memórias mais rápidas e menores (cache) para armazenar dados frequentemente acessados e memórias mais lentas (disco rígido/SSD) para armazenar grandes volumes de dados menos utilizados.

Um exemplo disso em sistemas web, é quando utilizamos o Redis para realizar o cache de uma listagem frequentemente acessada pelo client. Isso reduz o tempo de resposta e o overhead de buscar novamente os dados no banco de dados.

8 - Estabilidade pela redundância

"Além de rápidos, os computadores precisam ser estáveis."

Em um serviço web por exemplo, isso pode se assemelhar a redes de servidor em cluster, onde há vários servidores que hospedam o serviço, e se caso um deles falhe, outro servidor assume a função. Nesses clusters é possível inclusive adicionar balanceadores de carga que distribuem requisições entre servidores. Caso um servidor fique sobrecarregado ou inativo, as requisições são direcionados a outro servidor.

Dia 11 - 1.1 Introdução - Organização e Projeto de Computadores: Interface Hardware/Software

Matheus Gomes — Thu, 10 Oct 2024 01:08:27 +0000

Antes de engrenar de vez na criação do meu sistema operacional, resolvi dar dois passos atrás e consumir dois livros:

Organização e Projeto de Computadores: Interface Hardware/Software - John Hennessy
Sistemas Operacionais: Conceitos e Mecanismos - Prof. Carlos A. Maziero

Também está no meu radar: Arquitetura de Computadores - Uma Abordagem Quantitativa - John Hennessy
Mas esse deixarei para o futuro.

Começando:
Esse capítulo destina-se a enfatizar a era "pós-PC", onde os PMD's (dispositivo móvel pessoal) estão substituindo os computadores desktop convencionais. Um exemplo de PMD é um smartphone, ou computador tablet.
Também elaborou um pouco sobre SaaS (Software as a Service) e Computação em Nuvem e processadores embutidos.
Após discorrer sobre esses assuntos, é apresentado uma série de questões que o livro propõe que poderão ser respondidas ao terminar de lê-lo:

Como os programas escritos em uma linguagem de alto nível, como C ou Java, são traduzidos para a linguagem de máquina e como o hardware executa os programas resultantes?
O que é a interface entre o software e o hardware, e como o software instrui o hardware a realizar as funções necessárias?
O que determina o desempenho de um programa e como um programador pode melhorar o desempenho?
Que técnicas podem ser usadas pelos projetistas de hardware para melhorar o desempenho?
Que técnicas podem ser usadas pelos projetistas de hardware para aumentar a economia de energia?
Quais são os motivos e as consequências da mudança recente do processamento sequencial para o processamento paralelo?
Desde o primeiro computador comercial em 1951, que grandes ideias os arquitetos de computador tiveram para estabelecer a base da computação moderna?

Por fim, o capítulo termina com as seguintes perguntas ao leitor:

O número de processadores embutidos vendidos a cada ano supera, e muito, o número de processadores para PC e até mesmo pós-PC. Você pode confirmar ou negar isso com base em sua própria experiência?

Eu, confirmo com um grandíssimo sim, principalmente por causa dessa notícia. Os processadores embutidos em sua grande maioria são usados em dispositivos IoT. E pensando na grande expansão desse mercado, é fácil confirmar isso.

Como mencionado anteriormente, tanto o software quanto o hardware afetam o desempenho de um programa. Você pode pensar em exemplo nos quais cada um dos fatores a seguir é o responsável pelo gargalo no desempenho? O algoritmo escolhido, A linguagem de programação ou compilador, O sistema operacional, O processador, O sistema de E/S e os dispositivos.

Algoritmo - Um algoritmo mal otimizado pode apresentar ineficiências. Complexidade computacional alta, uso ineficiente de memória e overhead desnecessário devem ser evitados ao máximo.

Linguagem de programação ou compilador - Linguagens interpretadas (Python e Ruby) e com compilação JIT (Java e C#) adicionam uma camada extra de processamento durante a execução. E linguagens que fazem uso do garbage collector também tendem a ser mais lentas.

Sistema operacional - Tenho certeza que há mais fatores, mas os que eu experienciei foram: má compatibilidade de suporte ao hardware (ubuntu), sobrecarga de segurança (windows defender) e gerenciamento de energia (notebook fora da tomada entrou em modo de economia).

Processador - Clock (frequência do processador), incompatibilidade de arquitetura (ARM, x86, x64), superaquecimento, número de núcleos... (com certeza há mais fatores que desconheço)

Sistema de E/S e os dispositivos - No momento, só me vem a cabeça o uso de discos rígidos lentos (HDD) e saturação de I/O.