DEV Community: Plínio Ribeiro

Threads na linguagem C

Plínio Ribeiro — Mon, 06 May 2024 12:12:10 +0000

O que são threads?

Vamos aos ensinamentos do mestre Tanenbaum (2016) no seu livro Sistemas Operacionais Modernos que escreve que "Um processo tem um espaço de endereçamento contendo o código e dados do programa, assim, como outros recursos". Em seguida, ele nos apresenta o conceito de threads: "um processo tem uma linha de execução (thread) de execução, normalmente abrevidado para apenas thread. O thread tem um contador de programa que controla qual instrução deve ser executada em seguida".

O autor pontua que "Processos são usados para agrupar recursos; threads são as entidades escalonadas para execução na CPU". Por fim, complementando, "os threads compartilham um espaço de endereçamento e outros recursos" e "processos compartilham memórias físicas, discos, impressoras e outros recursos".

Para este estudo estarei utilizando a Linguagem C e a biblioteca POSIX threads. Que segundo a sua documentação (man pthreads):

POSIX.1 specifies a set of interfaces (functions, header files) for threaded programming commonly known as POSIX threads, or Pthreads. A single
process can contain multiple threads, all of which are executing the same program. These threads share the same global memory (data and heap
segments), but each thread has its own stack (automatic variables).

Para utilizar, adicionamos a flag -pthread ao compilar os nossos códigos.

Exemplo simples de uso de threads na linguagem C.

#include <stdio.h>
#include <pthread.h>

void    *thread_function(void *arg);

int     main(void) {
  pthread_t     thread1;
  pthread       thread2;
  int           i;

  pthread_create(&thread1, NULL, thread_function, NULL);
  pthread_create(&thread2, NULL, thread_function, NULL);

  pthread_join(thread1, NULL);
  pthread_join(thread2, NULL);

  printf("Threads finalizadas.\n");

  return 0;
}

void    *thread_function(void *arg) {
  int       i;

  for (i = 1; i <= 10; i++) {
    printf("Thread ID: %ld, Número: %d\n", pthread_self(), i);
  }

  pthread_exit(NULL);
}

Explicação das funções acima:

Função	Descrição
`pthread_create`	Cria uma nova thread
`pthread_exit`	Conclui uma chamada de thread
`pthread_join`	Espera que um thread específico seja abandonado

Sincronização de threads

Race Conditions

Como vimos acima sobre threads, que diferente de processos, threads compartilham o mesmos recursos disponíveis para o processo a qual pertencem. Nesse cenário, pode acontecer comportamentos inesperados quando threads acessam um mesmo recurso ao mesmo tempo ou mesma região da memória.

A esses casos são denominados race conditions.

Podemos dizer que está ocorrendo uma race condition quando "dois ou mais processos estão lendo ou escrevendo alguns dados compartilhados e o resultado final depende de quem executa precisamente e quando", Tanenbaum (2016).

Coleciono também, o conceito presente em POSIX thread (pthread) libraries.

A contention or race condition often occurs when two or more threads need to perform operations on the same memory area, but the results of computations depends on the order in which these operations are performed. Mutexes are used for serializing shared resources such as memory.

Vejamos o exemplo. O código abaixo, temos uma variável global count que será incrementada n vezes por 5 threads "ao mesmo tempo".

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
#include <assert.h>

volatile unsigned int count = 0;
void    *increment(void*);

int     main(int argc, char **argv)
{
    pthread_t       threads[5];
    int             i;
    int             qtd;

    if (argc < 2)
        qtd = 10000;
    else 
        qtd = atoi(argv[1]);
    i = 0;
    while (i < 5) 
    {
        pthread_create(&threads[i], NULL, increment, (void*)&qtd);
        i++;
    }
    i = 0;
    while (i < 5) 
    {
        pthread_join(threads[i], NULL);
        i++;
    }
    printf("Count: %d\n", count);
    return (0);
}

void    *increment(void *ptr)
{
    int         i;
    int         qtd;

    qtd = *(int*)ptr;
    i = 0;
    while(i++ < qtd)
        count++;
    return ((void*)0);
}

Executando o código com valores mais altos podemos ver que os resultados não saem com esperado.

❯ make race
gcc -Wall -Wextra -Werror -pthread race.c -o race 
❯ ./race
Count: 44599
❯ ./race 10
Count: 50
❯ ./race 100
Count: 500
❯ ./race 1000
Count: 5000
❯ ./race 10000
Count: 26448
❯ ./race 100000
Count: 150643
❯ ./race 1000000
Count: 1506256

Aproveitar e colocar uma nota sobre o modificador volatile.

Ele indica para o compilador que variável pode ser modificada por fatores externos, aplicando uma restrição às otimições realizadas pelo compilador.

ThreadSanitizer

Uma ferramenta que pode nos ajudar é ThreadSanitizer.

Para utilizarmos, compilarmos nosso código com flag -fsanitize=thread.
Ao executar, é disparado um aviso que está ocorrendo uma condição de corrida à variável count. Vejamos:

❯ ./race
==================
WARNING: ThreadSanitizer: data race (pid=14464)
  Read of size 4 at 0x56453e338014 by thread T2:
    #0 increment <null> (race+0x141a)

  Previous write of size 4 at 0x56453e338014 by thread T1:
    #0 increment <null> (race+0x1432)

  Location is global 'count' of size 4 at 0x56453e338014 (race+0x000000004014)

  Thread T2 (tid=14467, running) created by main thread at:
    #0 pthread_create ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:969 (libtsan.so.0+0x605b8)
    #1 main <null> (race+0x1333)

  Thread T1 (tid=14466, finished) created by main thread at:
    #0 pthread_create ../../../../src/libsanitizer/tsan/tsan_interceptors_posix.cpp:969 (libtsan.so.0+0x605b8)
    #1 main <null> (race+0x1333)

SUMMARY: ThreadSanitizer: data race (/mnt/c/Users/win11/lab/conpar/yolinux/race+0x141a) in increment
==================
Count: 27076
ThreadSanitizer: reported 1 warnings

Por mais informações, veja: https://www.cs.columbia.edu/~junfeng/11fa-e6121/papers/thread-sanitizer.pdf

Diante desse cenários que temos a sincronização de *threads*.

Mecanismos para lidar com sincronização de threads

A biblioteca POSIX threads fornece três mecanismo para lidar com sincronização de threads. São:

Mecanismo	Descrição
Mutexes (Mutual exclusion lock)	Bloqueia o acesso a determinada variável/recurso para outros threads
Joins	Faz com que um `thread` aguarde que outras estejam terminadas
Variáveis de condição	Utiliza o tipo `pthread_cond_t` para controlar o acesso a determinada variável/recurso

Mutexes

Mutexes são utilizados para evitar comportamentos inesperados ou inconsistências com os dados durante operações de vários threadsna mesma área de memória ou recurso. É uma forma de prevenir race conditions.

O seu uso se dá por meio de uma variável do tipo pthread_mutex_t. Quando um thread tentar acessar uma área de memória, primeiro ela tentar bloquear a variável mutex; caso consiga: realiza sua ação; caso contrário: aguarda até que a mutex esteja liberada para uso.

Mais um vez, trago aqui os ensinamentos do mestre Tanenbaum (2016):

Um mutex é uma variável compartilhada que pode estar em um de dois estados: destravado ou travado. Em consequência, apenas 1 bit é necessário para representá-lo, mas na prática muitas vezes um inteiro é usado, com 0 significando destravado e todos os outros valores significando travado.

Vamos utilizar o mesmo código acima e o modificar para implementar mutexes.

// Logo após as importações da bibliotecas 
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;

// [...]

// Na função increment modificamos 
    pthread_mutex_lock(&mutex);
    while(i++ < qtd)
        count++;
    pthread_mutex_unlock(&mutex);
    return ((void*)0);

Compilamos e executamos. Como se poder, a versão com mutexes comportou conforme esperado.

❯ ./race 100000
Count: 159154
❯ ./race_mutexes 100000
Count: 500000

Explicando:

Função / tipo	Descrição
`PTHREAD_MUTEX_INITIALIZER`	Macro utilizado para inicializar uma mutex
`pthread_mutex_lock()`	Aqui está adquirindo o lock de uma variável mutex
`pthread_mutex_unlock(&mutex)`	Desbloqueia o lock

Join

Utilizamos o mecanismo join quando desejamos aguardar que um thread seja finalizado antes de continuar com a execução do código. É semelhante às chamadas das funções wait e waitpid no contexto de processos.

Para isso fazemos uso da função pthread_join, que atua quando "um thread precisa esperar outro terminar seu trabalho e sair antes de continuar. O que esperando chamada pthread_join para esperar outro thread específico terminar" Tanenbaum (2016);

Indicamos qual thread é para aguardar passando como primeiro argumento da função. O segundo argumento da função é informado quando queremos recuperar algum valor retornado pelo thread. Esse argumento é facultativo, caso não se tenha valor para recuperar, passamos NULL como argumento.

É assinatura da função

int pthread_join(pthread_t thread, void **retval);

Vejamos um exemplo o uso de join

#include <stdio.h>
#include <pthread.h>

#define NTHREADS 10
void                *thread_function(void*);
pthread_mutex_t     mutex = PTHREAD_MUTEX_INITIALIZER;
int                 counter = 0;

int     main(void)
{
    pthread_t   thread_id[NTHREADS];
    int         i;

    i = 0;
    while (i < NTHREADS)
    {
        pthread_create(&thread_id[i], NULL, thread_function, NULL);
        i++;
    }
    i = 0;
    while (i < NTHREADS)
    {
        pthread_join(thread_id[i], NULL);
        i++;
    }
    printf("Counter: %d\n", counter);
    return (0);
}

void    *thread_function(void*)
{
    printf("Thread number: %ld\n", pthread_self());
    pthread_mutex_lock(&mutex);
    counter++;
    pthread_mutex_unlock(&mutex);
    return ((void*)0);
}

No exemplo acima, inicializamos 10 threads, que chamam a função thread_function, que por sua vez, incrementa o valor de counter, e depois aguardamos o encerramento de cada uma dos threads inicializados para depois continuar com o fluxo de execução do código.

Observa que aqui também utilizamos mutexes para controlar as alterações da variável counter, e assim evitar que o programa se comporte de forma inesperada: seja deixando de fazer uma incrementação, seja incrementando a mais. Bem, que nesse caso, como a quantidade de incrementações é pífia a chance de ocorrer uma condição de corrida é baixa.

Uma explicação à chamada da função pthread_self(): ela retorna o ID da thread chamada, é mesmo valor que retornado por uma chamada pthread_create(3) quando criamos um thread.

Variáveis de Condição

Variáveis de condição são variáveis que suspende a execução do thread até que determinada condição seja atendida. Segundo Tanenbaum (2016), "variáveis de condição permitem que threads sejam bloqueados devido a alguma condição não estar sendo atendida".

Deve-se atentar, que quando estamos lidando com variável de condição, sempre devemos associar ela com um mutex, o qual será responsável por bloquear a região crítica.

Acrescentando, segundo o OSTEP: a "condition variable is an explicit queue that threads can put themselves on when some state of execution (i.e., some condition) is not as desired (by waiting on the condition); some other thread, when it changes said state, can then wake one (or more) of those waiting threads and thus allow them to continue (by signaling on the condition)".

Abaixo temos o código que utiliza variável de condição e mutex. Fazemos uso de dois threads. A execução varia entre a execução de cada thread, cada execução realiza uma atividade de incremento da variável count. Utilizamos a variável de condição para controlar a execução dos threads.

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

pthread_mutex_t count_mutex         = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t  condition_var       = PTHREAD_COND_INITIALIZER;

#define     COUNT_DONE      10
#define     COUNT_HALT1     3
#define     COUNT_HALT2     6

void        *fcount1(void*);
void        *fcount2(void*);

int     main(void)
{
    volatile int    count;
    pthread_t       th1;
    pthread_t       th2;

    count = 0;
    pthread_create(&th1, NULL, fcount1, (void*)&count);
    pthread_create(&th2, NULL, fcount2, (void*)&count);

    pthread_join(th1, NULL);
    pthread_join(th2, NULL);

    printf("Final count: %d\n", count);
    return (0);
}

void        *fcount1(void *ptr) 
{
    int     *to_increment;

    to_increment = (int*)ptr;
    while (1)
    {
        pthread_mutex_lock(&count_mutex);
        pthread_cond_wait(&condition_var, &count_mutex);
        *to_increment += 1;
        printf("[fcount1] value: %d\n", *to_increment);
        pthread_mutex_unlock(&count_mutex);
        if (*to_increment >= COUNT_DONE)
            pthread_exit(NULL);
    }
}

void        *fcount2(void *ptr) 
{
    int     *to_increment;

    to_increment = (int*)ptr;
    while (1)
    {
        pthread_mutex_lock(&count_mutex);
        if (*to_increment < COUNT_HALT1 || *to_increment > COUNT_HALT2)
            pthread_cond_signal(&condition_var);
        else 
        {
            *to_increment += 1;
            printf("[fcount2] value: %d\n", *to_increment);
        }
        pthread_mutex_unlock(&count_mutex);
        if (*to_increment >= COUNT_DONE)
            pthread_exit(NULL);
    }
}

Explicando as funções acima uti

O macro PTHREAD_COND_INITIALIZER:

A função pthread_cond_wait:
http://man.yolinux.com/cgi-bin/man2html?cgi_command=pthread_cond_wait

A função pthread_cond_signal
http://man.yolinux.com/cgi-bin/man2html?cgi_command=pthread_cond_signal

Uma observação quanto ao uso de while e porque não podemos utilizar if.

Semáforos

Outro mecanismo para controle de threads, são os semáforos. Bem o que são?

Desenvolvidos pelo cara, o E. W. Dijkstra, é a utilização de uma variável inteira para contar o número de sinais de acordar salvos para uso futuro, assim ensina o Tanenbaum (2016).

Realizamos duas operações básicas sobre semáforos: incrementar ou decrementar.
Quando desejamos sinalizar que operações estão disponíveis para serem realizar, incrementamos o valor do semáforo.
E a cada vez que um operação é realizada, o decrementamos até chegar o valor de zero.
O ato de decrementar o semáforo dever ser realizado antes de realizar alguma atividade. Funciona como uma verificação de disponibilidade.

Se após, o valor for superior a (-1), o thread segue o fluxo de execução, caso contrário, ela vai dormir até ser acordado novamente para uma nova tentativa.

Referências

Tanenbaum, Andrew S. Sistemas operacionais modernos / Andrew S. Tanenbaum, Herbert Bos; tradução Jorge Ritter; revisão técnica Raphael Y. de Camargo. – 4. ed. – São Paulo: Pearson Education do Brasil, 2016
https://fidelissauro.dev/concorrencia-paralelismo/
http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html
https://github.com/wdalmorra/Problema-Produtor-Consumidor/tree/master
https://hpc-tutorials.llnl.gov/posix/
https://wiki.inf.ufpr.br/maziero/lib/exe/fetch.php?media=socm:socm-12.pdf
https://pages.cs.wisc.edu/~remzi/OSTEP/threads-cv.pdf
https://www.cs.columbia.edu/~junfeng/11fa-e6121/papers/thread-sanitizer.pdf
https://pt.stackoverflow.com/questions/10175/para-que-serve-o-modificador-volatile-do-c-c
https://embarcados.com.br/modificadores-de-acesso-na-linguagem-c/

Notas de Estudos sobre processos Linux

Plínio Ribeiro — Wed, 20 Mar 2024 15:53:59 +0000

Processos Linux

1.1 Conceitos básicos de processos Linux

O que é um processo? Respondendo diretamente: um processo é um binário em execução. O qual pode ser dito, em outras palavras, é uma abstração de um software em execução. Segundo Tanenbaum (2016, p. 60), "Um processo é apenas uma instância de um programa em execução, incluindo os valores atuais do contador do programa, registradores e variáveis".

De forma simples, um processo é um programa em execução. Em outras palavras, é um programa ativo, realizando suas atividades pelo qual foi desenvolvido, é um software em execução, em atividade.

Cada processo tem um ID, que é atribuido pelo sistema operacional, cujo valor máximo em sistemas Linux é 32768.
Para vermos o ID dos processos em execução, podemos utilizar a ferramenta ps.

Exemplo:

> ps
  PID TTY          TIME CMD
 1479 pts/3    00:00:01 zsh
 1483 pts/3    00:00:00 zsh
 1491 pts/3    00:00:00 zsh
 1493 pts/3    00:00:00 zsh
 1494 pts/3    00:00:00 gitstatusd-linu
 3816 pts/3    00:00:00 ps

Quando estamos programando na linguagem C, um ID de um processo é representado pelo tipo pid_t. O qual é definido no cabeçalho <sys/types.h>.

1.1.1 Criação de processos

Tanenbaum (2016, p. 61), aponta quatro eventos principais em que os processos são criados:

Inicialização do sistema.
Execução de uma chamada de sistema de criação de processo por um processo em execução.
Solicitação de um usuário para criar um novo processo.
Início de uma tarefa em lote.

Em termos de código, para se criar um processo em ambiente Linux, fazemos uma chamada ao kernel, por meio da syscall fork() que criará um clone do processo que a chamou. Em seguida, é chamada uma das funções da família exec() que substitui a imagem do processo atual pela imagem do novo processo.

Também, podemos utilizar a função system(). Essa forma é mais direta e simples, porém não muito eficiente, pois faz uma chamada para o shell sh -c antes de iniciar o novo processo com o programa desejado.

O processo que deu origem ao novo processo é chamado de processo pai e o novo processo é chamado de processo filho.

1.1.2 Término de processos

Um processo poderá terminar de forma voluntária ou involuntária. Ensina Tanenbaum (2016, p. 63) as quatras formas que um processo poderá terminar:

Saída normal (voluntária): encerra a execução após realizar o seu trabalho;
Erro fatal (involuntário): ocorre quando o processo tenta acessar um recurso não disponível;
Saída por erro (voluntária): ocorre um erro na execução do programa, a exemplo, dividir por zero;
Morto por outro processo (involuntário): outro processo pede ao sistema operacional interromper a execução de outro processo.

1.1.3 Estados do processo

Um processo em execução pode se encontrar em um dos três estados: em execução, pronto e bloqueado.

Em execução: o processo está executando suas instruções;
Pronto: o processo está pronto para ser executado, aguardando a decisão do sistema operacional de o colocar em execução;
Bloqueado: está à espera de um evento para que seja possível continuar a sua execução.

Anota-se que todos os estados de um processo são determinados pelo sistema operacional, por meio do escalonador de processos.

1.1.4 Exemplos de código

Neste tópico, será destinado para exemplos de códigos utilizando a API do Linux para manusear processos.

Função fork()

No primeiro exemplo, vamos criar um processo com a utilização da função fork() para criar um processo filho.

A função fork() cria um clone do processo pai, compartilhando mesmo trecho de código e recursos do processo criador.

É a assinatura da função.

#include <sys/types.h>
#include <unistd.h>
pid_t fork(void);

Esta função retorna o seguinte:
Em caso de sucesso, retornar o PID do processo filho para o pai, e 0 para o processo criado. Em caso de falha, -1 é retornado.

Outro detalhe, o processo filho inicia a sua execução a partir do fork(). O processo filho não inicia a sua execução a partir da função main.

No exemplo seguinte, o processo pai declara a variável x, a assinala um valor para ela. Posteriormente, faz uma chamada para a criação de novo processo, e, respectivamente, cada um alterar o valor da variável e o imprimi na tela.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <assert.h>

int     main(void) 
{
    pid_t   cpid;
    int     x;

    x = 100;
    printf("Initial x value: %d\n", x);
    cpid = fork();
    if (cpid == 0)
    {
        x = 50;
        printf("Child x value: %d\n", x);
    }
    else 
    {
        x = 500;
        printf("Parent x value: %d\n", x);
    }
    return (0);
}

No exemplo seguinte, temos um caso onde os processos pai e filho compartilham o mesmo file descritor, escrevendo no mesmo arquivo, o qual foi aberto pelo pai.

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <fcntl.h>
#include <assert.h>

int     main(void) 
{
    pid_t   cpid;
    int     fd;

    fd = open("out.txt", O_CREAT | O_WRONLY | O_TRUNC, S_IRWXU);
    if (fd == -1) 
    {
        perror("Erro ao abrir o arquivo");
        exit(1);
    }
    if ((cpid = fork()) == -1) 
    {
        perror("Fork error\n");
        exit(1);
    }
    if (cpid == 0) 
    {
        dprintf(fd, "Child writed!\n");
    }
    else 
    {
        dprintf(fd, "Parent writed!\n");
        close(fd);
    }
    return (0);
}

Funções wait() e waitpid()

Vemos no primeiro exemplo acima, que o processo pai imprimi o valor de x antes do filho. E caso for necessário, que o processo criador aguardasse a execução de um ou mais processos filhos.

Para esses casos, temos as funções wait() e waitpid().

São as suas assinaturas:

#include <sys/types.h>
#include <sys/wait.h>

pid_t wait(int *wstatus);
pid_t waitpid(pid_t pid, int *wstatus, int options);

Segundo ensinam STEVENS, W. Richard e RAGO, Stephen (2013), quando um processo termina, seja normalmente e não, o kernel informa o processo pai enviando o sinal (SIGCHLD). O envio desse sinal é assíncrono, o que pode ocorrer com o processo pai em execução ou não. O processo criador pode escolher entre ignorar o sinal, via de regra, ou executar alguma outra ação.

Há outros sinais que podem ser enviados, mas, por ora, se atermos ao SIGCHLD.
Como o envio do sinal é assíncrono, temos situação em que devemos suspender a execução do processo pai, enquanto aguardamos o término de um ou mais processos filhos.

Nesse cenário, que entram em cena as funções wait() e waitpid().

Sendo direto, o MAN relata que as funções esperam por uma mudança de status no processo. Uma explicação que gostei é do Prof. Eduardo Zambon:
"A chamada wait() é usada para esperar por mudanças de estado nos filhos do processo chamador (pai) e obter informações sobre aqueles filhos cujos estados tenham sido alterados (ex: morte de um filho). Quando o pai executa o wait(), se o filho já teve o seu estado alterado (ex: já morreu) no momento da chamada, ela retorna imediatamente; caso contrário, o processo chamador é bloqueado até que ocorra uma mudança de estado do filho ou então um “signal handler” interrompa a chamada (isso será explicado mais adiante)"

Essas funções retornam o PID do processo encerrado ou -1 no caso de erro.

fonte: http://www.inf.ufes.br/~rgomes/so_fichiers/roteiro2.pdf

Vejamos um exemplo de uso da função wait().

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int     main(void) 
{
    pid_t   cpid1;
    pid_t   cpid2;
    int     status;

    cpid1 = fork();
    if (cpid1 == -1 ) 
        exit(EXIT_FAILURE);

    if (cpid1 == 0)
    {
        printf("Processo filho um\n");
        exit(EXIT_SUCCESS);
    }
    cpid2 = fork();
    if (cpid2 == -1 ) 
        exit(EXIT_FAILURE);
    if (cpid2 == 0)
    {
        printf("Processo filho dois\n");
        exit(EXIT_SUCCESS);
    }
    wait(&status);
    printf("Processo pai\n");
    exit(EXIT_SUCCESS);
}

Observa-se que passamos o endereço de uma variável na chamada da função wait(). Por meio dela, o processo pai receberá informações a respeito do processo filho. No qual se dá por meio de flags binárias, as quais são lidas por meio de macros específicos.

Mais um vez, coleciono as anotações do Prof. Eduardo Zambon:

O POSIX expecifica seis macros, projetadas para operarem em pares:

WIFEXITED(status): permite determinar se o processo filho terminou normalmente. Se WIFEXITED avalia um valor não zero, o filho terminou normalmente. Neste caso, WEXITSTATUS avalia os 8-bits de menor ordem retornados pelo filho através de _exit(), exit() ou return de main.
WEXITSTATUS(status): retorna o código de saída do processo filho.
WIFSIGNALED(status): permite determinar se o processo filho terminou devido a um sinal.
WTERMSIG(status): permite obter o número do sinal que provocou a finalização do processo filho.
WIFSTOPPED(status): permite determinar se o processo filho que provocou o retorno se encontra congelado/suspenso (stopped).
WSTOPSIG(status): permite obter o número do sinal que provocou o congelamento do processo filho.

Vejamos um exemplo com uso de verificação do retorno da chamada da função wait() e do valor do status:

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

int     main(void) 
{
    pid_t   cpid1;
    pid_t   r_wait;
    int     status;

    cpid1 = fork();
    if (cpid1 == -1 ) 
        exit(EXIT_FAILURE);

    if (cpid1 == 0)
    {
        printf("Processo filho - PID: %d\n", getpid());
        exit(EXIT_SUCCESS);
    }
    r_wait = wait(&status);
    printf("Valor de retorno da chamada wait: %d\n", r_wait);
    if (WIFEXITED(status)) 
        printf("Processo filho um retornou o código: %d.\n", WEXITSTATUS (status));
    exit(EXIT_SUCCESS);
}

Outra função é a waitpid(), a qual, diferente da sua irmã, ela permite que definamos o PID de um processo específico que estamos aguardando o seu encerramento.

Exemplo com waitpid(), no qual trocamos a parte final do código acima pelo seguinte:

  waitpid(cpid1, NULL, 0);
  printf("Processo filho um terminou\n");
  waitpid(cpid2, NULL, 0);
  printf("Processo filho dois terminou\n");
  exit(EXIT_SUCCESS);

Diferenças entre wait() e waitpid

As funções wait() e waitpid se diferenciam nos seguintes.

A função wait() bloqueia o processo até que qualquer dos filhos termine.

A função waitpid(), aguarda um processo filho específico tenha o seu status alterado. Por padrão, ela aguarda o término do processo indicado, porém, o seu comportamento pode ser alterado por meio das opções do terceiro argumento.

São as opções disponíveis.

WNOHANG: retorna imediatamente, em vez de bloquear, se não houver nenhum processo filho que tenha terminado ou parado. Isso permite verificar o status dos processos filhos sem ficar bloqueado.
WUNTRACED: Essa opção faz com que a função waitpid() também retorne informações sobre processos filhos parados (stopped), além dos processos filhos que terminaram. Por padrão, a função só retorna informações sobre processos filhos que terminaram.
WCONTINUED: retorna informações sobre processos filhos retomados (resumed) após terem sido parados. Isso é útil quando se deseja monitorar o ciclo de vida completo dos processos filhos, incluindo pausas e retomadas.

Referências:

STEVENS, W. Richard; RAGO, Stephen A. Advanced programming in the UNIX environment. Addison-Wesley, 2013.
Tanenbaum, Andrew S. Sistemas operacionais modernos / Andrew S. Tanenbaum, Herbert Bos; tradução Jorge Ritter; revisão técnica Raphael Y. de Camargo. – 4. ed. – São Paulo: Pearson Education do Brasil, 2016.
MATTHEW, Neil; STONES, Richard. Beginning linux programming. John Wiley & Sons, 2008.
https://pages.cs.wisc.edu/~remzi/OSTEP/
https://pages.cs.wisc.edu/~remzi/OSTEP/cpu-api.pdf
http://www.inf.ufes.br/~rgomes/so_fichiers/roteiro1.pdf
http://www.inf.ufes.br/~rgomes/so_fichiers/roteiro2.pdf
https://www.educative.io/answers/wait-vs-waitpid-in-c

Notas introdutórias à ferramenta Address Sanitizer

Plínio Ribeiro — Mon, 15 Jan 2024 19:25:43 +0000

A Address Sanitizer, ASan, é uma ferramenta que permite identificar erros de memória em tempo de execução.
Em outras palavras, quando executamos nossos programa e ocorre algum erro de memória: a ASan acusa a ocorrência do problema, bem como interrompendo a sua execução.

Segundo o descrito no paper "AddressSanitizer: A Fast Address Sanity Checker", ela é:

a new memory error detector. Our tool finds out-of-bounds accesses to heap, stack, and global objects, as well as use-after-free bugs. It employs a specialized memory allocator and code instrumentation that is simple enough to be implemented in any compiler, binary translation system, or even in hardware.

Por meio dela é possível identificar os seguintes erros:

Use after free (dangling pointer dereference)
Heap buffer overflow
Stack buffer overflow
Global buffer overflow
Use after return
Use after scope
Initialization order bugs
Memory leaks

Ela já vem disponível nos dois compiladores mais utilizados GCC e CLANG. Sua utilização é por meio de flags
definidas durante a compilação. Assim, a ASan insere no código da aplicação, que está sendo compilada, mecanismos que permite "identificar diversos problemas de acesso à memória, incluindo o uso de memória desalocada, estouros de buffer no stack e no heap, acesso à memória não inicializada e vazamentos de memória" (PRADO, 2018).

A sua forma de atuação pode ser consultada na documentação. Mas, basicamente, a ASan atua trocando as chamadas malloc/free do código pelas suas próprias versões de gerenciadores de acesso/uso de memória.

A utilização dessa ferramenta é fundamental para identificar problemas/erros escondidos. Por que escondidos? Pois, pode ocorrer que o programa seja executado em sua totalidade com aparente estado de normalidade, todavia, sem que seja disparado algum erro ou interrompido a sua execução. Sendo que, há alguns erros que podem estarem ocorrendo e que terão consequências em outras execuções ou exporem o software à alguma vulnerabilidade.

Deve-se ressaltar que o seu uso provoca uma sobrecarga na execução e processamento da aplicação. Em razão disso, é recomenddo a sua utilização apenas em versões de desenvolvimento e testes.

Uso

Para habilitar o ASan, adicione a seguinte flag quando estiver compilando o progama.

-fsanitize=address (clang)

gcc app.c -fsanitize=address -o app

Tem outras flgas que podem serem consultadas na documentação.

Exemplos de usos

Erro Stack buffer overflow

"Buffer Overflow, também chamado de Buffer Overrun, é uma anomalia em um programa em que, ao escrever dados em um buffer (armazenamento temporário de dados), a escrita ultrapassa o tamanho do buffer e começa a escrever nos espaços adjacentes."

Veja-se o exemplo abaixo:

#include <stdio.h>
#include <string.h>

int main(void) 
{
   char     str[2];

   str[0] = 'O';
   str[1] = 'l';
   str[2] = 'a';
   str[3] = '\0';
   printf("%s\n", str);
   return (0);
}

Quando compilado e executado, não é apresentado qualquer erro;

> gcc test.c -o test 
> ./test
> Ola

Agora, quando compilado com a flag -fsanitize=address e executado, a ASan entra em ação para apresentar os erros encontrados e interromper a respectiva execução.

> gcc test.c -fsanitize=address -o test
> ./test

=================================================================
==389==ERROR: AddressSanitizer: stack-buffer-overflow on address 0x7ffe948a7662 at pc 0x55d86850528f bp 0x7ffe948a7630 sp 0x7ffe948a7628
WRITE of size 1 at 0x7ffe948a7662 thread T0
    #0 0x55d86850528e in main (/home/senhor/School42/ft_printf/test+0x128e)
    #1 0x7f06f5c9cd09 in __libc_start_main ../csu/libc-start.c:308
    #2 0x55d8685050b9 in _start (/home/senhor/School42/ft_printf/test+0x10b9)

Address 0x7ffe948a7662 is located in stack of thread T0 at offset 34 in frame
    #0 0x55d868505184 in main (/home/senhor/School42/ft_printf/test+0x1184)

  This frame has 1 object(s):
    [32, 34) 'str' (line 6) <== Memory access at offset 34 overflows this variable
HINT: this may be a false positive if your program uses some custom stack unwind mechanism, swapcontext or vfork
      (longjmp and C++ exceptions *are* supported)
SUMMARY: AddressSanitizer: stack-buffer-overflow (/home/senhor/School42/ft_printf/test+0x128e) in main
Shadow bytes around the buggy address:
  0x10005290ce70: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290ce80: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290ce90: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290cea0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290ceb0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
=>0x10005290cec0: 00 00 00 00 00 00 00 00 f1 f1 f1 f1[02]f3 f3 f3
  0x10005290ced0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290cee0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290cef0: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290cf00: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
  0x10005290cf10: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
Shadow byte legend (one shadow byte represents 8 application bytes):
  Addressable:           00
  Partially addressable: 01 02 03 04 05 06 07
  Heap left redzone:       fa
  Freed heap region:       fd
  Stack left redzone:      f1
  Stack mid redzone:       f2
  Stack right redzone:     f3
  Stack after return:      f5
  Stack use after scope:   f8
  Global redzone:          f9
  Global init order:       f6
  Poisoned by user:        f7
  Container overflow:      fc
  Array cookie:            ac
  Intra object redzone:    bb
  ASan internal:           fe
  Left alloca redzone:     ca
  Right alloca redzone:    cb
  Shadow gap:              cc
==389==ABORTING

Erro Memory leaks

Outro exemplo é com Memory leaks. Memory leaks ou vazamento de memória, é segundo a Wikipédia, "um fenômeno que ocorre quando um programa de computador gerencia incorretamente alocações de memória de maneira que certa memória não é liberada quando não é mais necessária".

Veja-se o exemplo abaixo:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv)
{
   char     *buffer;

   buffer = malloc(1024);
   sprintf(buffer, "%s", argv[1]);
   printf("%s\n", buffer);
   return (0);
}

Quando compilado e executado, novamente, não é apresentado qualquer erro;

> gcc test.c -o test 
> ./test hello
> hello

Agora, quando compilado com a flag -fsanitize=address e executado, a ASan entra em ação para apresentar os erros encontrados.

> gcc test.c -fsanitize=address -o test
> ./test hello                                                                                                                                                         hello                                                                                                                                                                                                                                                                                                                                         =================================================================                                                      ==822==ERROR: LeakSanitizer: detected memory leaks                                                                                                                                                                                                                                                                                            Direct leak of 1024 byte(s) in 1 object(s) allocated from:                                                                                                                 #0 0x7f5f09215e8f in __interceptor_malloc ../../../../src/libsanitizer/asan/asan_malloc_linux.cpp:145                                                                  #1 0x5624c33ff1bd in main (/home/senhor/School42/ft_printf/test+0x11bd)                                                                                                #2 0x7f5f08fbbd09 in __libc_start_main ../csu/libc-start.c:308                                                                                                                                                                                                                                                                            SUMMARY: AddressSanitizer: 1024 byte(s) leaked in 1 allocation(s).

Referências:

Estudos de Bases Numéricas

Plínio Ribeiro — Wed, 23 Aug 2023 11:03:38 +0000

Como os números são representados

Em um primeiro momento precisamos entender como os números são representados. Os números são representados por meio do sistema posicional ou notação posicional.

Cada número ou dígito tem seu valor em função da posição que ocupa na sequência numérica e pela base (sistema) que faz parte.

Como escreve os professores Profs. M.Sc. Lucio M. Duarte e Ph.D. Avelino Zorzo:

S*istemas numéricos são posicionais, isto é, cada quantidade é representada em uma única forma, mediante uma certa combinação de símbolos, que têm um significado distinto, segundo sua posição.*

No sistema decimal, como já comentado, cada posição tem um valor intrínseco que
equivale a dez vezes o valor da posição que está imediatamente a sua direita.

Fonte: https://www.inf.pucrs.br/~zorzo/ii/downloads/representacaodedados.pdf

Para sabemos o valor de um número, não basta saber o seu valor individual, mas também qual base ele faz parte e qual a sua posição quando está representando em uma sequência de símbolos.

Vamos partir a explicação do nosso sistema decimal, ou base 10, o qual já estamos acostumados a utilizar.

A exemplo, o número 422.

O qual pode escrito da seguinte forma:

422 = 4x100 + 2x10 + 2x1

Ou da seguinte forma.

422 = 4x10^2 + 2x10^1 + 2x10^0

Explicando:

Para sabermos o valor do 4, que representa 400, temos que saber a sua posição, contando da direita para a esquerda começando com zero. Que nesse caso é 2. Deve observar que consideramos o início da contagem das posições da direita para a esquerda.

Depois multiplicamos 4 pela base, neste caso 10, elevada a sua posição: 2.

*4*10^2 = 4*100 = 400*

Para o valor de 2 que representa 20.

*2*10^1 = 2*10 = 20*

E para o valor de 2 que 2;

*2*10^0 = 2*1 = 2*.

Somamos os resultados: 400 + 20 + 2 = 422.

Concluindo. O valor do símbolo depende da posição que ocupa em relação a todo o conjunto que está representando, bem como da base que está sendo utilizada na representação.

Nesse sentido, podemos obter a partir da seguinte equação de contagem:

$$
D\;=\;\sum_{i\;=\;-n\;}^{p-1}\;d_i\;\times\;r^i\;=d_{p-i}\times r^{p-1}+...+d_1\times r^1+d_0\times r^0+d_{-1}\times r^{-1}+...+d_{-n}\times r^{-n}
$$

Onde:

– D : número;
– r : base ou radix;
– d : dígito (0 ≤ d < r);
– p : quantidade de dígitos na parte inteira;
– n : quantidade de dígitos na parte fracionária;

Por fim uma observação importante:

Observa-se que os sistemas não posicionais dificultavam a representação de números
“grandes”, ou seja, era necessário muitos símbolos para isso. Por outro lado, em um sistema
posicional é possível representar números cada vez maiores com os mesmos símbolos. Outra
grande vantagem do sistema de numeração com valor posicional é que as operações (adição,
subtração, multiplicação e divisão) são de execução bem mais simples.
Em um sistema de numeração posicional o número nove, por exemplo, não tem o
mesmo valor quando está colocado na fileira nas unidades, dezenas, centenas e, assim por
diante. Por exemplo, 959 – No sistema de numeração que usamos hoje, 9 na unidade, tem
como valor posicional nove unidades, na centena o 9 tem valor novecentos. Nesse sistema,
o valor de um algarismo depende da posição que ele ocupa no número.

fonte: https://repositorio.ufgd.edu.br/jspui/bitstream/prefix/1375/1/KatiuceFernandesRocha.pdf

Mais informações:

https://pt.wikipedia.org/wiki/Notação_posicional

https://edisciplinas.usp.br/pluginfile.php/4190820/mod_resource/content/5/PCS3115 2018S1 Sistemas de Numeracao v2.pdf

Bases numéricas

Uma base numérica representa uma quantidade de símbolos possíveis que podemos utilizar para representar um número.

A elas temos a seguinte definição formal.

Definição (Sistema de numeração de base b). Dado um número natural b>1 e o conjunto de símbolos {±,0,1,2,…,b−1}, a sequência de símbolos

$$
(d_nd_{n-1}..d_1d_0,d_{-1}d_{-2}...)_b
$$

representa o número positivo

$$
d_n⋅b^n+d_{n-1}⋅b^{n-1}+\cdots+d_0⋅b^0+d_{-1}⋅b^{-1}+d_{-2}⋅b^{-2}+\cdots
$$

Para representar números negativos usamos o símbolo − a esquerda do numeral.

Mais informações: https://www.ufrgs.br/reamat/CalculoNumerico/livro-py/rdneadm-sistema_de_numeracao_e_mudanca_de_base.html

Assim, escolhemos um número b como base e b símbolos, um para cada número de 0 a b − 1, chamados de algarismos (dígitos). Multiplicando um destes números (algarismos) pelas potências de b (1, b^2, b^3, etc.) e somando-os, conseguimos expressar um número em uma determinada base. Por exemplo, 1352 = 1 · 10^3 + 3 · 10^2 + 5 · 10^1 + 2 · 10^0. Esse número, por exemplo, está representado na base decimal, ou seja, b = 10 .

Assim, os algarismos em qualquer número dado representa um múltiplo de alguma potência da base, potência essa que depende da posição ocupada pelo algarismo. Como exemplo de sistema posicional temos nosso sistema de numeração posicional decimal indo-arábico.

Nesse sistema, por exemplo, 5 em 506 representa 5 · 10^2 ou 500. Agora, 5 em 58 representa 5 x 10^1 ou 50. Observe que o zero é importante para indicar a ausência de alguma potência da base.

Fonte: https://repositorio.ufgd.edu.br/jspui/bitstream/prefix/1375/1/KatiuceFernandesRocha.pdf

São várias as bases numéricas, mas aqui apenas trataremos de estudar algumas mais utilizadas no ambiente de programação. Quais são:

Binária;
Octal;
Decimal;
Hexadecimal;

Em seguida falarei um pouco sobre cada um delas.

Base Binária

No sistema binário ou base binária temos apenas dois símbolos para compor os números. São: 0 e 1. Por isso é chamado de binário em razão da quantidade de símbolos que fazem parte: dois.

São incluídos como símbolos pertencentes a determinada base iniciando-se em 0 até b - 1. Conforme explicado, acima, na definição formal de bases numéricas.

Que neste caso são:

$$
{0, 1}
$$

Onde cada símbolo ou digito tem o seu valor em função do produto da multiplicação dele por 2 elevado a n-enésima posição. Ou seja, construímos a representação de um número qualquer somando as potências de dois presentes na representação.

Como temos apenas 0 e 1 como dígitos disponíveis, quando temos um valor a ser considerado e quando temos zero, dispensa-se a explicação.

Posição	9	8	7	6	5	4	3	2	1	0
Valor	512	256	128	64	32	16	8	4	2	1

Exemplos de representação de números decimais na base binária:

2 = 00010

4 = 00100

10 = 1010

25 = 11001

É a base que os sistemas computacionais entendem e operam. Diferente de nós que utilizamos o sistema decimal. Dado que utilizam os seguintes algarismos: 1 bit (para indicar presença de tensão) e 0 bit (para indicar ausência de tensão).

Toda operação computacional primeiro converte o número para base 2, realiza as operações e depois converte para a base original, qual seja: decimal, hexadecimal ou outra que o usuário esteja utilizando.

Base Octal

Base octal ou base 8 (oito). Nesta base temos 8 (oito) algarismos para representar um número qualquer. São:

$$
{0, 1, 2, 3, 4, 5, 6, 7}
$$

Exemplos de números na base dez e sua representação na base octal:

4 = 4

10 = 12

42 = 52

127 = 177

Mais na frente será demonstrado como é feita a conversão acima exemplificada.

Base Decimal

A base decimal ou base 10 (dez) é que utilizamos no nosso dia a dia. Ela dispõe de 10 (algarismos) para representar os números. Quais são:

$$
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9}
$$

Base Hexadecimal

A base hexadecimal ou base 16 (dezesseis) são utilizados dezesseis símbolos, que vão de 0 até 9 mais as letras A até F. No qual as letras são equivalentes no sistema decimal aos valores de 10 até 15.

$$
{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F}
$$

Exemplos de números na base dez na base hexadecimal:

4 = 4

10 = A

42 = 2A

127 = 2F

Curiosidade: Na linguagem Javascript, pode-se obter o valor decimal de número hexadecimal utilizando o prefixo 0x antes do número na base 16.

console.log(0x7F);
// 127

Conversão de decimal para para as demais bases

Dado um número na base decimal podemos escrevê-lo em qualquer outra base usando sucessivamente a divisão por resto ou Euclidiana. O número que no passo n-ésimo for quociente passa a ser dividendo no passo de ordem n + 1. O processo conclui quando o quociente for zero.

Referências: LINARES, Juan López; BRUNO-ALFONSO, Alexys; BARBOSA, Grazielle Feliciani. Bases numéricas na olimpíada internacional de matemática. Revista Professor de Matemática Online, v. 7, n. 02, 2019.

Continuando a explicação. Após chegarmos a momento que o consciente for zero, alinhamos os restos da divisão na ordem inversa que foram encontrados.

Deve-se atentar que deve utilizar o maior quociente inteiro da divisão.

Converter o número 42 na base 10 para a base 2:

Para o cálculo do resto utilizaremos o operador módulo, representado por %.

42 / 2 = 21 42 % 2 = 0

21 / 2 = 10 21 % 2 = 1

10 / 2 = 5 10 % 2 = 0

5 / 2 = 2 5 % 2 = 1

2 / 2 = 1 2 % 2 = 0

1 / 2 = 0 1 % 2 = 1

Feitas as divisões sucessivas, basta alinhar os restos na ordem inversa: 101010. Assim temos a representada do número 42 na base 10 na base 2.

Este mesmo procedimento é para a conversão para qualquer outra base. Basta substituir o dois pela base final desejada.

Conversão da parte fracionária

Agora, para conversão de um número fracionário ou de um número com uma parte fracionária separamos a parte inteira da fracionária. Enquanto para a parte inteira realizamos o procedimento acima explicado; utilizando o método das divisões sucessivas. Para o número fracionário ou parte fracionária realizamos multiplicações sucessivas, da parte fracionária, até que o resultado seja apenas inteiros. Ou que repitam, que é quando estaremos diante de uma dizima periódica.

Por exemplo, converter o número 42,75 na base 10 para a base 2:

A parte inteira do número já foi feito acima, então descartar-se repetir os mesmo cálculos. Aqui é interessante apenas a parte fracionária.

0,75 * 2 = 1,5

0,50 * 2 = 1

Nesse caso, diferentemente do que fazemos com a parte inteira, vamos posicionando a parte inteira resultante da multiplicação na ordem que foram calculados, ou encontrados.

No nosso exemplo, tivemos como resultado 11.

Desse modo, o 42,75 na base 10 para a base 2 é: 101010,11.

Conversão das demais bases para decimal

Para convertemos um número em determinada base para decimal, basta aplicar a definição do que vimos quando escrevi sobre ***********************bases numéricas*********************** linhas acima.

Relembrando. Para conseguir o valor do número, na base dez, a partir de determinada base fazemos o seguinte.

Multiplicamos os dígitos pela base elevada a sua posição. Quando número for fracionário, ou parte fracionária, a posição é negativa. Após somamos os produtos e teremos a representação do número na base dez.

Algoritmo:

$$
d_n⋅b^n+d_{n-1}⋅b^{n-1}+\cdots+d_0⋅b^0+d_{-1}⋅b^{-1}+d_{-2}⋅b^{-2}+\cdots
$$

Exemplo para: 101010,11.

$$
\small
x = (101010,11)_2 \newline
x = (1*2^5)+(0*2^4)+(1*2^3)+(0*2^2)+(1*2^1)+(0*2^0)+(1*2^{-1}))+(1*2^{-2}) \newline
x = 32+0+8+0+2+0+0,5+0,25
x = 42,75
$$

Prática de programação. Conversão de bases numéricas

De uma base n para a base decimal

Agora vou trazer um exemplo de um código que converte um número em determinada base para decimal na linguagem C.

#include <stdio.h>

int  value_of(char ch);
int  base_from_to_decimal(char *nbr, int base_from);

int   main(void) {

  printf("42 to b10 = %d\n", base_from_to_decimal("42", 10));
  printf("2A to b10 = %d\n", base_from_to_decimal("2A", 16));
  printf("101010 to b10 = %d\n", base_from_to_decimal("101010", 2));
  printf("\n");

  return (0);
}

int   value_of(char ch) {
  if (ch >= '0' && ch <= '9')
    return (ch - '0');
  else if (ch >= 'a' && ch <= 'f')
    return (ch - 'a' + 10);
  else if (ch >= 'A' && ch <= 'F')
    return (ch - 'A' + 10);

  return (0);
}

int  base_from_to_decimal(char *nbr, int base_from)
{
  int   result;

  result = 0;
  while(*nbr)
    {
        result = result * base_from + value_of(*nbr);
        nbr++;
    }

  return (result);
}

O que interessa no código acima são as funções value_of e base_from_to_decimal.

A função value_of devolve o inteiro correspondente ao um caractere na tabela ASCII (American Standard Code for Information Interchange ou ”Código Padrão Americano para o Intercâmbio de Informação”).

Esse processo de recuperação é necessário pelo fato que a número a ser convertido é passado para a função base_from_to_decimal como uma cadeia de caracteres, mais comumente conhecido: uma string.

A função base_from_to_decimal recebe dois parâmetros: a cadeia de caracteres que contém a representação do número a ser convertido para decimal e um inteiro indicando qual base ela está organizado.

No corpo, declaramos e é inicializado uma variável, result, do tipo inteiro, que será retornada com o valor do número convertido de decimal.

Em seguida realizamos uma interação sobre a ***string*** recebida. Para cada caractere recuperemos o seu valor decimal da tabela ASCII com a função value_of. Esse valor é somado ao produto do valor de result, a cada interação, multiplicado pela base de origem.

Uma vez encerrado o *loop* a variável result é retornada com a representação do número na base dez.

O código é uma implementação bem grosseira. Apenas como demonstração do conceito aqui estudado. Observar-se que esse código realiza apenas conversão de números inteiros.

Da base decimal para uma base n

O código abaixo converte um número decimal para uma outra base desejada.

#include <stdio.h>
#define MAX_SIZE 32

void    to_base(int nbr, char *base, int len, char resulted[], int i)
{
    if (nbr/len != 0)
        to_base((nbr/len), base, 2, resulted, i);

    while (resulted[i] != '\0'&& i < MAX_SIZE)
        i++;

    resulted[i] = base[nbr%len];
}

int main(void) 
{
  char resulted[MAX_SIZE];
  int  nbr;
  int  i;

  nbr = 42;
  i= 0;
  if (nbr < 0)
  {
    sing++;
    resulted[0] = '-';
  }
  to_base(nbr, "01", 2, resulted, i);
  printf("%d to B2: %s\n", nbr, resulted);
  return (0);
}

Explicando rapidamente a função main.

Nela é declarada um vetor de caracteres no qual será armazenado a representação do nosso número convertido. Em seguida é declarado a variável nbr , tipo inteiro, que será utilizada para definir o número que se deseja converter e o inteiro i que terá a função de definir o início do posicionamento dos caracteres. Pois, caso o número seja negativo, será necessário posicionar o sinal negativo no início do vetor.

Logo, é feito um verificação se o número é negativo, se sim é realizado o procedimento descrito acima.

Feito isso, é realizada uma chamada para a função to_base que recebe cinco argumentos:

O número a ser convertido, do tipo inteiro: nbr;
A base desejada, do tipo cadeia de caracteres: base;
O tamanho da base, do tipo inteiro: len;
Um vetor de caracteres onde será salvo a representação numérica convertida: resulted;
E um inteiro, que serve com index para o o vetor: i.

A função to_base é recursiva. Ela chama a se mesma por quanto o valor de nbr for diferente de zero. E a cada nova chamada o valor de nbré dividido por len. Lembrando que, a cada nova chamada da função, ela é empilhada na pilha com os valores atuais da chamada. Aqui não vou entrar nos detalhes de como é a execução de uma função recursiva.

Quando o resultado da divisão for zero as chamadas recursivas se encerram e volta a continuar o fluxo de execução, da função, a partir de cada chamada.

Outro ponto importante a lembrar: é que devemos alinhar os restos da divisão na ordem inversa que forem encontrados. Nesse caso, devemos salvar o resto da cada divisão a partir do resultado da última chamada da função até a primeira. Enquanto é desempilhada da pilha de chamadas.

Continuando a explicação da função.

No laço while seguinte, recortado do código da função to_base :

while (resulted[i] != '\0' && i < MAX_SIZE)
        i++;

O valor de i que é incrementado até que seja encontrado um local no vetor resulted que possa receber o dígito, desde que seja respeitado o tamanho máximo disponível pelo vetor.

Em seguida, o valor do digito resultante do módulo do valor presente de nbr por len é armazenado na vetor que representará o número convertido ao final. A posição é dada pelo valor de i.

Imperar anotar que nos dois exemplos não é implementado uma forma de lidar com números fracionários, mas caso o leitor tenha interesse: Neste artigo o autor implementa um algoritmo que converte um número de ponto flutuante para uma ***string*** que representa o número na base 2.

[Estudos de C] Escrevendo uma versão simples do utilitário cat

Plínio Ribeiro — Wed, 23 Aug 2023 11:00:50 +0000

O cat é um utilitário de linha de comando que lê arquivos, seja apenas um ou uma sequência informada, e escreve o seu conteúdo em fluxo de destino.

O nome cat é derivado de: (con)catenate files.

Conforme o manual (man cat) é descrito com duas funções: concatenar arquivos e imprimir o seu conteúdo em um fluxo de saída.

Utilizamos o cat da seguinte forma:

cat [OPTION]... [FILE]...

Essa implementação é com fim de tentar a resolução, própria, do Exercício 01, da Piscine 10 de C, da Escola 42. Não participei de nenhuma piscina, apenas encontrei os PDFs relativos no Github e estou tentando fazer os exercícios.

São as regras a implementação desta versão:

Como pode se ler das orientações acima, a implementação desta versão tem limitações das funções que poderão ser utilizadas.

Nesta minha implementação, optei por utilizar apenas as funções: open, close, read e write.

Antes de adentrar diretamente na escrita da versão do cat , vou estar escrevendo algumas notas de introdutórias.

File Descritores

Um ************File Descritor (FD)************ é um número inteiro único maior que zero que guarda referência para um arquivo aberto pelo sistema operacional.

Quando pede ao sistema operacional o acesso a determinado arquivo ou fluxo de dados, o ***kernel*** retorna, um *********File Descritor********* de um registro na tabela global de registros de arquivos do sistema operacional.

Por meio dele o processo ou programa pode acessar os dados constantes no arquivo, ou fluxo referenciado pelo FD. Observa-se que o pedido de acesso tenha sido acatado com sucesso.

Em sistemas baseados em Unix e Linux os primeiros FD referem aos fluxos stdin, stdout e stderr.

Nome	File Descriptor	Descrição	Abreviatura
Standard input	0	O fluxo de dados padrão para entrada, por exemplo, em um pipeline de comando. No terminal, o padrão é a entrada do teclado do usuário.	stdin
Standard output	1	O fluxo de dados padrão para saída, por exemplo, quando um comando imprime texto. No terminal, o padrão é a tela do usuário.	stdout
Standard error	2	O fluxo de dados padrão para a saída relacionada à ocorrência de um erro. No terminal, o padrão é a tela do usuário.	stderr

Os valores dos FD acima descritos podem serem acessados indicando diretamente os seus valores ou por meio de constantes presentes nas bibliotecas <unistd.h> e <stdio.h>.


STDIN_FILENO	stdin
STDOUT_FILENO	stdout
STDOUT_FILENO	stderr

Outra questão referente aos FD é a possibilidade de redirecionar os fluxos de dados entre diferentes FD por meio do *pipe*. Mas esse tópico tratarei em outro momento.

Referências:

https://www.computerhope.com/jargon/f/file-descriptor.htm

Função `open()`

A função open() permite a realização de conexão entre um arquivo e um FD. Por meio dessa função, o programa tem acesso ao FD de um arquivo informado como parâmetro na chamada da função.

A função tem o seguinte protótipo:

int open(const char *pathname, int flags); int open(const char *pathname, int flags, mode_t mode);

E é disponibilizada pela biblioteca <fcntl.h>.

O primeiro argumento, path, é pelo qual passamos o caminho do caminho ou fluxo de dados que queremos acessar/abrir.

O segundo argumento é o tipo de acesso que desejamos(leitura, escrita, leitura e escrita, etc). Esse passamos informando a respectiva, quis são constantes definidas no cabeçalho <fcntl.h>. Exemplos de algumas **flags** definidas e mais utilizadas.

Flag	Descrição
O_EXEC:	Abre o arquivo para execução, apenas. Não se aplica a diretórios.
O_RDONLY	Apenas leitura.
O_RDWR	Abre o arquivo para leitura e escrita.
O_RDWR	Abre um diretório para pesquisa, apenas. Não se aplica a não diretórios.
O_WRONLY	Abre o arquivo apenas para a escrita.

O terceiro argumento, facultativo, é utilizado quando estamos criando um novo arquivo. Pois, é por meio dele que definimos as permissões iniciais do arquivo criado.

***************Retorno:*************** O retorno da chamada da função open() é um número inteiro positivo que representa FD do respectivo arquivo ou fluxo de dados requerido a ser aberto. Caso contrário, a função retorna -1 e define o tipo de erro que ocorreu.

O código abaixo é a implementação de utilização da função open() que cria, se não existir um arquivo e salva nele que o usuário digitar no stdin, por enquanto o programa estiver em execução.

#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>

#define MAX_BUF 1024

int main(int argc, char **argv)
{
    char    *file;
    char    buf[1024];
    int     fd;
    int     flags;
    int     bytes_reads;
    int     bytes_writes;

    if (argc < 2)
    {
        perror("Arquivo de destino não definido.\n");
        return (1);
    }

    flags = O_WRONLY | O_CREAT | O_TRUNC;
    file = argv[1];

    fd = open(file, flags, S_IRUSR | S_IWUSR);
    if (fd == -1)
    {
        perror("Erro ao abrir o arquivo!\n");
        return (1);
    }

    while ((bytes_reads = read(STDIN_FILENO, buf, MAX_BUF - 1)) > 0)
    {
        bytes_writes = write(fd, buf, bytes_reads);
        if (bytes_writes != bytes_reads)
        {
            perror("Error ao escrever no arquivo\n.");
            close(fd);
            return (1);
        }
    }   

    if (bytes_reads == -1)
    {
        perror("Erro na leitura do STDIN\n");
        close(fd);
        return (1);
    }   

    close(fd);
    return (0);
}

O código ficou um pouco longo, mas bom que aproveito como exemplo para as explicações abaixo, sobre as demais funções.

Para mais informações: man 2 open.

Referências:

Função `close()`

A função close() fecha um FD aberto e referenciado. A chamamos quando precisamos fechar um arquivo ou fluxo de dados abertos. Fazemos isso passamos o arquivo ou fonte de dados como parâmetro, no qual será terminado a conexão com o FD referente.

A função tem o seguinte protótipo:

int close(int fd);

E é disponibilizada pela biblioteca <unistd.h>.

A função retorna 0 no caso de sucesso ou -1, em caso tenha ocorrido algum erro.

Como pose se ver no código anteriormente exposto, a chamamos para fechar o FD do arquivo aberto antes do retorno final da função main().

Função `read()`

A função read() lê uma certa quantidade de bytes a partir de um FD e os salva em um buffer.

Ela tem o seguinte protótipo:

ssize_t read(int fd, void *buf, size_t count);

O primeiro argumento é a indicação do FD no qual será feita a leitura. O segundo é o do buffer que será salvo os dados lidos e o terceiro é a quantidade de **bytes** a serem lidos/transferidos.

E é disponibilizada pela biblioteca <unistd.h>.

Quanto ao retorno:

Cada chamada retorna uma contagem do número de bytes transferidos. Na leitura, o número de bytes retornados pode ser menor que o número solicitado.
Um valor de retorno de zero bytes implica o fim do arquivo, e -1 indica algum tipo de erro.

Referências: RITCHIE, Dennis M. et al. The C programming language. Bell Sys. Tech. J, v. 57, n. 6, p. 1991-2019, 1978.

Como pode ser observado no código recortado do exposto acima, a função read() é chamada no contexto de um loop while. Por enquanto o valor retornado for maior que zero, os dados lidos, por quantidade definida: a vez, são salvos no na variável buf e valor da quantidade de bytes lidos são salvos na variável bytes_reads.

Após a execução, é feita uma verificação se ocorreu algum erro na leitura.

while ((bytes_reads = read(STDIN_FILENO, buf, MAX_BUF - 1)) > 0)
    {
        bytes_writes = write(fd, buf, bytes_reads);
        if (bytes_writes != bytes_reads)
        {
            perror("Error ao escrever no arquivo\n.");
            close(fd);
            return (1);
        }
    }   

    if (bytes_reads == -1)
    {
        perror("Erro na leitura do STDIN\n");
        close(fd);
        return (1);
    }

Função `write()`

A função write() escreve uma quantidade n de bytes provenientes de um buffer em um FD informado.

Ela tem o seguinte protótipo:

ssize_t write(int fd, const void *buf, size_t count);

O primeiro argumento é o FD onde serão escritos os dados, o segundo é do ***buffer*** no qual serão provenientes e o terceiro é quantidade de **bytes** que serão escritos por vez.

A função é disponibilizada pela biblioteca <unistd.h>.

Quanto ao retorno:

Para gravação, o valor de retorno é o número de bytes gravados. Ocorreu um erro se esse número não for igual ao número solicitado.

Referências: RITCHIE, Dennis M. et al. The C programming language. Bell Sys. Tech. J, v. 57, n. 6, p. 1991-2019, 1978.

Implementação de uma versão simples do utilitário cat

Escrita as breves notas acima, agora é vez de escrever sobre a implementação do utilitário cat.

Nas primeiras linhas são escritas as inclusões das bibliotecas necessárias, a definição da constante referente à quantidade de ***bytes*** que serão lidos e escritos por vez e o protótipo das funções.

#include <unistd.h>
#include <fcntl.h>

#define MAX_BUF 1024

void    ft_cat(int fd);
void    clear_buf(char *);

Em seguida tem o corpo da função main().

int     main(int argc, char **argv)
{
    int     i;
    int     fd;

    if (argc == 1)
    {
        fd = STDIN_FILENO;
        ft_cat(fd);
    }
    else 
    {
        i = 1;
        while (i < argc)
        {
            fd = open(argv[i], O_RDONLY);
            if (fd == -1)
            {
                write(2, "Error opening the file\n", 30);
                return (1);
            }
            ft_cat(fd);
            close(fd);
            i++;
        }
    }

    return (0);
}

Nela é declarada duas variáveis do tipo inteiro: i e fd.

Em seguida é verificado se foi informado arquivos para serem lidos ou não. Caso não tenham sido informados pelo usuário, o variável fd recebe o FD referente ao stdin, por meio da constante STDIN_FILENO. Após, é chamada a ft_cat(fd) passando o respectivo fd.

Por outro lado, na situação do usuário tenha informado um ou mais arquivos; é atribuído o valor 1 para a variável i e dado início ao loop, que será executado por enquanto i for menor que o valor da variável argc.

Para cada interação do loop: Um arquivo é aberto por meio da função open() e o seu respectivo FD é salvo na variável fd; é feita uma verificação de erro e, se estiver tudo ok, a função ft_cat() é chamada tedndo o FD atual como parâmetro.

Por fim, as últimas linhas de execução do loop é: fechar o arquivo após a execução da função ft_cat() e o incremento da variável i para acessar o próximo arquivo, se houver.

Antes de passar para a explicação da função ft_cat(); apenas anotar aqui sobre a função clear_buf(). Que tem a tarefa de limpar a memória de alguma array recebida como parâmetro.
Assim, evita que haja restos de dados no buffer, principalmente quando estamos o utilizando no contexto do loop e leitura e escrita.

void    clear_buf(char *buf)
{
    int     i;
    i = 0;
    while(i < MAX_BUF)
        buf[i++] = '\0';
}

Agora, as notas para função ft_cat(). Segue o código da respectiva.

void    ft_cat(int fd)
{
    int     bytes_reads;
    int     bytes_writes;
    char    buf[MAX_BUF];

    bytes_reads = 0;
    bytes_writes = 0;
    clear_buf(buf);

    while ((bytes_reads = read(fd, buf, MAX_BUF - 1)) > 0)
    {
        buf[bytes_reads - 1] = '\0';
        bytes_writes = write(1, buf, bytes_reads);
        if (bytes_writes != bytes_reads)
        {
            write(2, "Error reading the file\n", 30);
            return;
        }
    }

    if (bytes_reads == -1)
    {
        write(2, "Error reading the file\n", 30);
        return;
    }

    write(1, "\n\n", 2);   
}

Ela recebe como parâmetro um inteiro que representa um FD de de onde os dados serão lidos. A escolha é pela opção, ao invés de receber o caminho de arquivo a ser lido, é pela possibilidade do FD referir tanto para arquivos, como também para outras fontes de da dados: tais como o stdin.

De início são declaradas três variáveis: duas do tipo inteiro e uma cadeia de caráteres com tamanho definido pela constante MAX_BUF. As variáveis bytes_reads e bytes_writes , como pelo nome dá para saber, serão onde armazenaremos os retornos das funções read() e write(). E a função buf[] será onde salvaremos os dados lidos e a serem, posteriormente, escritos no stdout.

Em seguida, são atribuídas as variáveis valores zero, com fim de evitar que haja dados remanescentes da memórias.

A atividade de leitura e escrita é feita no contexto de um *loop* while*.*

O *loop* é executado por enquanto o retorno da chamada da função read() for maior que zero. Na chamada da dessa função passamos, como parâmetro o FD atual da chamada da função ft_cat() , o buf onde os dados serão salvos e a quantidade de **bytes** que serão lidos por vez.

No corpo do *loop, adicionamos o caractere de terminação na última posição do buf. Após é feita a chamada da função write() para escrever no stdout os dados presentes no buf. Um verificação de erro é feita para checar se quantidade de *bytes** escritos é igual a quantidade a ser escrita. Caso haja alguma diferença, é disparado um erro.

Por fim, encerrada a execução do while, outra verificação de erro é feita relativa à chamada da função read() .

Conclusão

Bem, está foi uma implementação simples do utilitário cat. Observando a proposta do desafio que apresentou restrições de recursos, o intuito com esta atividade é aprender a utilização das funções mais básicas de manipulação de entradas e saídas de dados na linguagem C.

Referências

https://twobithistory.org/2018/11/12/cat.html

https://en.wikipedia.org/wiki/Cat_(Unix)

https://history-computer.com/understanding-cat-command-in-linux-with-examples/

https://austinedger.medium.com/unix-commands-lets-build-cat-59b8a91b9708

O que é o “Hoisting”?

Plínio Ribeiro — Sun, 24 Apr 2022 12:31:56 +0000

Continuando os escritos pontuais da linguagem JavaScript, hoje vou escrever sobre o “Hoisting”.

Antes de continuar é importante avisar da necessidade de conhecer o conceito de escopos global e local.

Na literatura é comum dizer que o Hositing é um processo no qual as declarações das variáveis e das funções são movidas para o topo do código durante o processo de compilação/interpretação. A imagem a seguir tentar mostrar como seria sob essa visão:

Na verdade, não é bem assim que ocorre, trata-se apenas de uma maneira didática de compreender o processo.

De acordo com o MDN, “as declarações de variável e função são colocadas na memória durante a fase de compilação, mas permanecem exatamente onde você as digitou no seu código.”.

Ou seja, todas as variáveis e funções com escopo global são alocadas na memória, sem que sejam retiradas das suas posições no código.

É como se o compilador/interpretador mapeasse todas as declarações das funções e variáveis.

O levantamento como dizemos acima não ocorre, como disse, é uma maneira didática de compreender o processo.

Impera salientar que ocorre apenas com as funções e variáveis com escopo global. Declarações com escopo local não sofrem o “Hoisting”.

Vamos para um exemplo de código para ver suas implicações práticas:

console.log(a) // undefined

var a = 1;

console.log(a) // 1

Veja que, apesar que a variável ‘a’ tenha sido declarada após o primeiro ‘console.log()’, o resultado na tela foi ‘undefined’, ou seja, para ela apenas não foi definido um valor.

Outro exemplo com ‘let’:

console.log(a) // ReferenceError: a is not defined

let a = 1;

console.log(a)

Agora quando declaramos a variável por meio do ‘let’ é retornado um erro de referência. É acusado que a variável não foi definida.

Isso acontece em razão do escopo local de ‘let’, assim, não sofre o Hoisting.

Essa é a diferença, por meio do processo de Hoisting, mesmo que a declaração seja posterior, o compilador/interpretador já a conhece, e apenas devolve que não foi inicializado nenhum valor para ela.

Por outro lado, quando a declaração tem natureza de escopo local. A sua chamada antes da declaração devolve um erro de referência: acusa-se que a variável ou função não foi declarada.

Diferenças entre var, let, e const na linguagem Javascript

Plínio Ribeiro — Sun, 03 Apr 2022 15:42:58 +0000

No post anterior eu expliquei sobre o conceito de escopos na linguagem Javascript. Neste trarei breves notas sobre a diferença na forma como declaramos variáveis no Javascript.

Qual é a diferença de declarar uma variável como var, let ou const.

Quem já programa na linguagem a um bom tempo, a regra era iniciar uma variável com var. Porém, após o ES2015 (ES6), novas formar surgiram, quais sejam: let e const.

Variáveis declaradas com var

Um aspecto importante quando utilizamos var é que ele tem escopo global e local (aqui). Como vimos quando estava falando de escopo, é possível acessar uma variável inicializada fora do escopo que a esta invocando.

Olha o exemplo:

var nome = "Heliot"

function pequi() {
    console.log(nome) // Heliot
}

pequi()

No exemplo acima, quando chamamos a função pequi(), ela consegue acessar o conteúdo da variável nome e exibir o seu conteúdo. Isto se dá pela razão de possuir o escopo global, ou seja, ela pode ser utilizada em várias partes do nosso código.

Impera anotar acerca da utilização de var é o hoisting realizado pela linguagem. Contudo, este assunto eu tratarei no próximo texto.

Outro aspecto importante da utilização de var é possibilidade de alterar o conteúdo da variável.

let nome = "Heliot"

function pequi() {
    nome = "Larissa"
    console.log(nome) // Larissa
}

pequi()

Quando chamamos a função pequi(), alteramos o valor da variável sem nenhum erro. Dado o seu escopo global de acessibilidade de leitura e modificação.

Variáveis declaradas com let

Let está sendo a forma preferida de declarar variáveis. Se diferencia de var em razão do seu escopo ser de bloco e não global.

O que é um bloco? Um bloco é um trecho de código iniciado e fechado por chaves “{}”. O que estiver nesse contexto é um bloco especifico.

Quando iniciamos uma variável com let em um bloco, sua acessibilidade se é limitada a este bloco. Vejamos um exemplo.

let n = 4;

if (n > 3) {
    let ola = "Olá para todos!";
    console.log(ola); // Olá para todos!
}

console.log(ola) // ReferenceError: ola is not defined

Veja que quando tentamos tentar acessar o conteúdo de ola fora do bloco é retornado um erro de referência.

Isso não acontece quando utilizamos var.

Olha outro exemplo.

let n = 4;

if (n > 3) {
    var ola = "Olá para todos!";

    console.log(ola); // Olá para todos!
    }

console.log(ola) // Olá para todos!

Já nesse exemplo foi possível acessar o conteúdo de ola. Isto se dá pelo hoisting, que explicarei no próximo texto.

Está limitação de acessibilidade é a principal diferença entre declara com var ou com let.

Quando a possibilidade de sofrer alterações, let permite que sejam realizadas. Veja:

let n = 4;

if (n > 3) {
    n = 0
}
console.log(n) // 0

Variáveis declaradas com const

A caraterística marcante da utilização de const é a sua imutabilidade. Quando declaramos variável com const ela não poderá ser alterar ou redeclarada.

const a = 1
a = 2 // TypeError: Assignment to constant variable.
console.log(a)

No exemplo acima, quando tentamos modificar o valor de a, é retornado um erro de tipo, que impede a alteração da variável já declarada.

Conclusão

Neste texto eu trouxe breves notas da diferença entre a utilização de var, let e const. Sendo essas últimas introduzidas pelo ES2015 (ES6).

Conhecer suas diferenças é importante na escrita diárias dos nossos códigos, para que sejam mais eficientes e com menos chances de provocarem bugs.

Diferenças entre escopos no JavaScript

Plínio Ribeiro — Fri, 01 Apr 2022 23:46:10 +0000

Quando programamos em qualquer linguagem é importante entender conceitos da linguagem. Neste texto vou trazer de forma breve o conceito de escopos na linguagem Javascript.

O que são escopos?

Escopos diz respeito aos limites que permitem que uma variável pode ser acessada dentro do código. Ou seja, quem poderá acessar o seu conteúdo para ler ou alterar.

No Javascript temos dois escopos: o escopo global e o escopo local.

Grosso modo, o escopo global é relativo a todo o código, tem a sua acessibilidade a todo o fluxo de código, incluindo quando dentro de alguma função.

Enquanto o escopo local é aquele declarando dentro de uma função. O limite de sua acessibilidade se restringe ao contexto “{}” da função no qual foi declarado.

Vejamos um exemplo:

var nome = "Charles"

function obterIdade() {
    var idade = 25
}

console.log(nome) // Charles
console.log(idade) // ReferenceError: idade is not defined

A variável nome está no escopo global e a variável idade está no escopo local da função “obterIdade”.

Quando tentamos exibir o conteúdo delas, nome é exibida normalmente, porém, para idade, é retornando um erro de referência. Acusa-se que idade não foi definida.

Este erro acontece porque a variável idade foi definida no escopo local da função “obterIdade”, nesse contexto ela só pode ser acessada dentro do domínio local dessa função. É uma limitação à acessibilidade da variável em ralação ao código.

Vejamos um outro exemplo, em que observamos a acessibilidade de uma variável declarada no escopo local por uma função.

var nome = "Charles"

function obterIdade() {
    var idade = 25
    console.log(nome) // Charles
    console.log(idade) // 25
}

obterIdade()

No exemplo acima é chamada a função “obterIdade” para que seja exibido o conteúdo das variáveis nome e idade. Nesse exemplo, a variável nome é impresso mesmo que declarada fora do escopo da função em que se encontra.

Isso acontece, porque ela foi declarada no escopo local, que permite que a variável seja acessada quando no âmbito do escopo global ou local de alguma função.

Assim, quando dizemos que a variável está declarada no escopo global, significa que sua acessibilidade é para todo o código. E quando referimos ao escopo local, é que ela só acessível no contexto da função que está localizada.

Compreender o conceito de escopos é importante, pois permite tenhamos conhecimento da capacidade de acesso, mutabilidade e o controle sobre código que estamos escrevendo.

Nota que aqui me restringi apenas a tratar sobre escopos na linguagem Javascript, não me adentrei na explicação de var, let e const. Em outro momento explicarei as diferenças entre essas formas de declarar uma variável, bem como o processo de hoisting.

DEV Community: Plínio Ribeiro

Threads na linguagem C

O que são threads?

Sincronização de threads

Race Conditions

ThreadSanitizer

Mecanismos para lidar com sincronização de threads

Mutexes

Join

Variáveis de Condição

Semáforos

Referências

Notas de Estudos sobre processos Linux

Processos Linux

1.1 Conceitos básicos de processos Linux

1.1.1 Criação de processos

1.1.2 Término de processos

1.1.3 Estados do processo

1.1.4 Exemplos de código

Função fork()

Funções wait() e waitpid()

Referências:

Notas introdutórias à ferramenta Address Sanitizer

Uso

Exemplos de usos

Erro Stack buffer overflow

Erro Memory leaks

Referências:

Estudos de Bases Numéricas

Como os números são representados

Bases numéricas

Base Binária

Base Octal

Base Decimal

Base Hexadecimal

Conversão de decimal para para as demais bases

Conversão da parte fracionária

Conversão das demais bases para decimal

Prática de programação. Conversão de bases numéricas

De uma base n para a base decimal

Da base decimal para uma base n

[Estudos de C] Escrevendo uma versão simples do utilitário cat

File Descritores

Função open()

Função close()

Função read()

Função write()

Implementação de uma versão simples do utilitário cat

Conclusão

Referências

O que é o “Hoisting”?

Diferenças entre var, let, e const na linguagem Javascript

Variáveis declaradas com var

Variáveis declaradas com let

Variáveis declaradas com const

Conclusão

Diferenças entre escopos no JavaScript

O que são escopos?

Função `open()`

Função `close()`

Função `read()`

Função `write()`