(Interprocess Communication)

Existem diversas maneiras de fazer dois processos distintos se comunicarem e isto torna bem difícil de escolher qual deles utilizar sem antes conhecermos o mínimo delas.

Low Level​

File​

Escrever os dados em um arquivo e esperar que outro processo leia o arquivo.

Pode ser estranho por ser muito simples mas acontece que passar dados entre processos não precisa ser complicado.

Exemplo:

• Processo 1
  • Constantemente verifica se o arquivo possui conteúdo
  • Se notar que possui, exibe o conteúdo na tela e esvazia o arquivo
• Processo 2
  • Constantemente verifica se o arquivo está vazio
  • Se notar que está vazio, escreve conteúdo no arquivo

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

int BUFFER_SIZE = 256;

int main(void) {
  FILE *file = fopen("input.txt", "r+");
  char *buffer = (char *)malloc(BUFFER_SIZE);
  int count = 0;

  memset(buffer, 0, BUFFER_SIZE);

  printf("Waiting message\n");

  do {
    fseek(file, 0, SEEK_SET);
    count = fread(buffer, sizeof(char), BUFFER_SIZE, file);
  } while (count == 0);

  printf("Reading message\n\n");

  do {
    printf("%s", buffer);
    count = fread(buffer, sizeof(char), BUFFER_SIZE, file);

    if (count < BUFFER_SIZE) {
      buffer[count] = '\0';
    }

  } while (count != 0);

  printf("\n\nClearing file\n");
  freopen("input.txt", "w", file);
  fclose(file);

  return 0;
}

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

int BUFFER_SIZE = 256;

int main(void) {
  FILE *file = fopen("../process1/input.txt", "w+");
  char *buffer = (char *)malloc(BUFFER_SIZE);
  int count = 0;

  memset(buffer, 0, BUFFER_SIZE);

  printf("Waiting file to be empty\n");

  do {
    fseek(file, 0, SEEK_SET);
    count = fread(buffer, sizeof(char), BUFFER_SIZE, file);
  } while (count != 0);

  printf("Writing message\n");
  fprintf(file, "Hello world");
  fclose(file);

  return 0;
}

Note que neste exemplo eu leio e escrevo no arquivo constantemente, porém isto é apenas um exemplo!

A realidade é que nós devemos ler ou escrever no arquivo na frequência que acharmos necessário para nosso programa. Só quero que você entenda que este método IPC é sobre processos usarem arquivos para interagir uns com os outros.

File Locking​

Escrever os dados em um arquivo e esperar que outro processo leia o arquivo porém respeitando as travas.

Um grande problema da maneira anterior é dois processos interagirem exatamente no mesmo momento com o arquivo. Imagine que um processo comece a ler enquanto um outro não terminou de escrever, isso fará com que ele leia conteúdo incompleto.

A maneira de travar arquivos varia em cada sistema operacional. Por exemplo, no Linux temos:

• flock
• lockf
• fcntl

Utilizaremos lockf para aprimorar o exemplo utilizado para arquivos:

• Processo 1
  • Constantemente:
    • Espera obter a trava para o arquivo
    • Verifica se o arquivo possui conteúdo
    • Libera a trava do arquivo se ele não tiver
  • Se notar que possui, exibe o conteúdo na tela, esvazia o arquivo e libera a trava
• Processo 2
  • Constantemente:
    • Espera obter a trava para o arquivo
    • Verifica se o arquivo possui conteúdo
    • Libera a trava do arquivo se ele tiver
  • Se notar que está vazio, escreve conteúdo no arquivo e libera a trava

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

int BUFFER_SIZE = 256;

int main(void) {
  int fd = open("input.txt", O_RDWR);
  char *buffer = (char *)malloc(BUFFER_SIZE);
  int count = 0;

  memset(buffer, 0, BUFFER_SIZE);

  printf("Waiting message\n");

  while (1) {
    lockf(fd, F_LOCK, 0);
    lseek(fd, 0, SEEK_SET);
    count = read(fd, buffer, BUFFER_SIZE);

    if (count != 0) {
        break;
    }

    lockf(fd, F_ULOCK, 0);
  }

  printf("Reading message\n\n");

  do {
    printf("%s", buffer);
    count = read(fd, buffer, BUFFER_SIZE);

    if (count < BUFFER_SIZE) {
      buffer[count] = '\0';
    }

  } while (count != 0);

  printf("\n\nClearing file\n");
  ftruncate(fd, 0);
  lockf(fd, F_ULOCK, 0);
  close(fd);

  return 0;
}

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

int BUFFER_SIZE = 256;

char* MESSAGE = "Hello world";

int main(void) {
  int fd = open("input.txt", O_RDWR);
  char *buffer = (char *)malloc(BUFFER_SIZE);
  int count = 0;

  memset(buffer, 0, BUFFER_SIZE);

  printf("Waiting file to be empty\n");

  while (1) {
    lockf(fd, F_LOCK, 0);
    lseek(fd, 0, SEEK_SET);
    count = read(fd, buffer, BUFFER_SIZE);

    if (count == 0) {
        break;
    }

    lockf(fd, F_ULOCK, 0);
  }

  printf("Writing message\n");
  ftruncate(fd, 0);
  lseek(fd, 0, SEEK_SET);
  write(fd, MESSAGE, strlen(MESSAGE));
  lockf(fd, F_ULOCK, 0);
  close(fd);

  return 0;
}

Signal​

Enviar um signal ao processo/thread para uma função tratar

Diferente de outros IPC, signal não é focado em comunicação no nível de aplicação, então não é muito utilizado para enviar dados, normalmente apenas para notificar outro processo da ocorrência de algo.

A melhor maneira de ter uma idéia da utilidade dos signals é vendo o signal.h do sistema operacional. No caso do Linux:

/* We define here all the signal names listed in POSIX (1003.1-2008);
   as of 1003.1-2013, no additional signals have been added by POSIX.
   We also define here signal names that historically exist in every
   real-world POSIX variant (e.g. SIGWINCH).

   Signals in the 1-15 range are defined with their historical numbers.
   For other signals, we use the BSD numbers.
   There are two unallocated signal numbers in the 1-31 range: 7 and 29.
   Signal number 0 is reserved for use as kill(pid, 0), to test whether
   a process exists without sending it a signal.  */

/* ISO C99 signals.  */
#define	SIGINT		2	/* Interactive attention signal.  */
#define	SIGILL		4	/* Illegal instruction.  */
#define	SIGABRT		6	/* Abnormal termination.  */
#define	SIGFPE		8	/* Erroneous arithmetic operation.  */
#define	SIGSEGV		11	/* Invalid access to storage.  */
#define	SIGTERM		15	/* Termination request.  */

/* Historical signals specified by POSIX. */
#define	SIGHUP		1	/* Hangup.  */
#define	SIGQUIT		3	/* Quit.  */
#define	SIGTRAP		5	/* Trace/breakpoint trap.  */
#define	SIGKILL		9	/* Killed.  */
#define	SIGPIPE		13	/* Broken pipe.  */
#define	SIGALRM		14	/* Alarm clock.  */

/* Archaic names for compatibility.  */
#define	SIGIO		SIGPOLL	/* I/O now possible (4.2 BSD).  */
#define	SIGIOT		SIGABRT	/* IOT instruction, abort() on a PDP-11.  */
#define	SIGCLD		SIGCHLD	/* Old System V name */

/* Not all systems support real-time signals.  bits/signum.h indicates
   that they are supported by overriding __SIGRTMAX to a value greater
   than __SIGRTMIN.  These constants give the kernel-level hard limits,
   but some real-time signals may be used internally by glibc.  Do not
   use these constants in application code; use SIGRTMIN and SIGRTMAX
   (defined in signal.h) instead.  */

/* Include system specific bits.  */
#include <bits/signum-arch.h>

/* Adjustments and additions to the signal number constants for
   most Linux systems.  */

#define SIGSTKFLT	16	/* Stack fault (obsolete).  */
#define SIGPWR		30	/* Power failure imminent.  */

/* Historical signals specified by POSIX. */
#define SIGBUS		 7	/* Bus error.  */
#define SIGSYS		31	/* Bad system call.  */

/* New(er) POSIX signals (1003.1-2008, 1003.1-2013).  */
#define SIGURG		23	/* Urgent data is available at a socket.  */
#define SIGSTOP		19	/* Stop, unblockable.  */
#define SIGTSTP		20	/* Keyboard stop.  */
#define SIGCONT		18	/* Continue.  */
#define SIGCHLD		17	/* Child terminated or stopped.  */
#define SIGTTIN		21	/* Background read from control terminal.  */
#define SIGTTOU		22	/* Background write to control terminal.  */
#define SIGPOLL		29	/* Pollable event occurred (System V).  */
#define SIGXFSZ		25	/* File size limit exceeded.  */
#define SIGXCPU		24	/* CPU time limit exceeded.  */
#define SIGVTALRM	26	/* Virtual timer expired.  */
#define SIGPROF		27	/* Profiling timer expired.  */
#define SIGUSR1		10	/* User-defined signal 1.  */
#define SIGUSR2		12	/* User-defined signal 2.  */

/* Nonstandard signals found in all modern POSIX systems
   (including both BSD and Linux).  */
#define SIGWINCH	28	/* Window size change (4.3 BSD, Sun).  */

Por padrão alguns signals já possuem comportamentos pré-definidos. Por exemplo: SIGINT.

Fica a sua escolha se você deseja sobreescrever o comportamento de um signal (caso ele tenha um comportamento padrão).

Quando um Signal é recebido pelo seu processo, o kernel pausa o fluxo normal do seu programa para executar a função que você definiu para aquele signal. Caso você não tenha definido alguma função, o comportamento padrão é executado (o qual pode ser ignorar o signal).

Signals permitem que você envie um inteiro ou ponteiro junto deles.

No caso de comunicação entre processos, apenas o inteiro costuma ser útil pois não podemos acessar o espaço de memória de outro processo.

Existem dois signals reservados para o uso da aplicação/usuário: SIGUSR1 e SIGUSR2. Podemos utiliza-los para a comunicação de nossos processo.

Por exemplo, enviar um número entre processos:

• Processo 1
  • Exibe o PID no terminal
  • Espera em loop pelo signal com o número
  • Encerrar ao receber o número
• Processo 2
  • Lê o PID passado por argumento
  • Envia o número para o processo desejado utilizadno o signal SIGUSR1

#include <signal.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

bool loop = true;

// Normally the function would only receive a number as paramter.
// But we setted flag SA_SIGINFO into our sigaction.
void on_user_signal(int signal_number, siginfo_t *signal_info, void *x) {
  printf("Received signal: %d\n", signal_number);
  printf("Together with number: %d\n", signal_info->si_value.sival_int);

  loop = false;
}

int main(void) {
  struct sigaction signal_action;
  signal_action.sa_flags = SA_SIGINFO;
  signal_action.sa_sigaction = on_user_signal;

  // sigaction() is recommended nowadays instead of signal().
  sigaction(SIGUSR1, &signal_action, NULL);

  printf("My PID: %d\n", getpid());
  printf("Waiting signal\n");

  while (loop) {
  }

  return 0;
}

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

int NUMBER = 42;

int main(int argc, char **args) {
  if (argc != 2) {
    printf("Needs to pass PID through arguments\n");
    return 1;
  }

  union sigval signal_value = {NUMBER};
  int pid = atoi(args[1]);

  printf("Sending signal to PID: %d\n", pid);
  printf("Together with number: %d\n", NUMBER);
  sigqueue(pid, SIGUSR1, signal_value);

  return 0;
}

Pipe​

Ler e escrever no pipe de outro processo filho/pai

O conceito de pipes é bem simples, você escreve em um lado do pipe e para alguém ler do outro lado dele.

Podemos criar um pipe com o comando pipe():

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

int main(void) {
  int file_descriptors[2];

  pipe(file_descriptors);

  printf("Pipe input: %d\n", file_descriptors[0]);
  printf("Pipe output: %d\n", file_descriptors[1]);

  return 0;
}

O comando pipe() inseri dois file descriptors, um para a entrada do pipe e outro para a saída do pipe, no nosso array. O comando também retorna -1 em caso de erro, mas eu irei ignorar tratamentos de erros nesses exemplos.

Começamos com o mínimo de IPC quando utilizando pipe() com fork():

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

int main(void) {
  char message[3];
  int file_descriptors[2];

  pipe(file_descriptors);

  if (fork()) {
    // Parent
    wait(NULL);
    read(file_descriptors[0], message, 3);
    printf("Message: %s\n", message);
  } else {
    // Child
    write(file_descriptors[1], "hi", 3);
  }

  return 0;
}

Cada processo possui seus próprios file descriptors, que por sua vez levam a um arquivo/pipe/etc. Porém quando fazemos um fork(), nossas entradas na tabela de file descriptors também é clonada.

Por exemplo, vamos supor que o ID do processo pai é 1034 e o filho nasceu com o ID 1035. Quando o filho nasce, ele herda todos os files descriptors:

Ou seja, o file descriptor com número 3 do pai e do filho irão levar ao mesmo arquivo/pipe/etc.

Isto não quer dizer que todos os file descriptors futuros seram compartilhados! Por exemplo:

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

int main(void) {
  int file_descriptors[2];
  int more_file_descriptors[2];

  pipe(file_descriptors);

  if (fork()) {
    // Parent
    pipe(more_file_descriptors);
    wait(NULL);
  } else {
    // Child
    pipe(more_file_descriptors);
  }

  return 0;
}

Ao chamar pipe() dentro do pai ou do filho, você está pedindo para o sistema operacional criar um pipe para aquele processo. O pai e filho receberam pipes distintos embora possuam o mesmo file descriptor (justamente pois file descriptors são identificadores únicos do processo).

Named Pipe (FIFO)​

Ler e escrever no pipe de outro processo

A diferença deste pipe para o anterior é que qualquer processo pode se ligar a ele, seja para escrever ou ler, pois ele é praticamente um arquivo no sistema.

O comando utilizado para criar o este pipe é mkfifo() e da mesma maneira que arquivos tem permissões... Você deve passar as permissões do arquivo como parâmetro, no nosso caso irei passar 0666 (rw-rw-rw).

Lembrando que um pipe só é um pipe se tiver pelo menos um lado de entrada e outro de saída, ou seja, funções de escrita/leitura do pipe irão ficar travadas até que o outro lado do pipe exista.

Enquanto não tiver ninguém lendo do pipe, o comando write() irá ficar em loop esperando alguém para ler.
Enquanto não tiver ninguém escrevendo no pipe, o comando read() irá ficar em loop esperando alguém começar a escrever.

• Processo 1
  • Tenta criar o named pipe com devidas permissões
  • Abre o named pipe para escrita
  • Escreve no arquivo a mensagem
• Processo 2
  • Tenta criar o named pipe com devidas permissões
  • Abre o named pipe para leitura
  • Le do arquivo a mensagem

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

int main(void) {
  mkfifo("pipefile", 0666);

  int file_descriptor = open("pipefile", O_WRONLY);
  write(file_descriptor, "hi", 3);
  printf("Message sent\n");
  
  return 0;
}

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

int main(void) {
  char message[3];

  mkfifo("pipefile", 0666);

  int file_descriptor = open("pipefile", O_RDONLY);
  read(file_descriptor, &message, 3);
  printf("Message: %s\n", message);
  
  return 0;
}

É possível ter mais que um processo lendo do mesmo pipe mas é incerto de quem receberá o conteúdo ou se dois processos irão receber o mesmo conteúdo.

Também é possível não ficar em loop esperando alguém começar a ler/escrever do outro lado do pipe, basta fazer um or quando abrindo o pipe (O_WRONLY | O_NDELAY ou O_RDONLY | O_NDELAY).

Message Queue​

Shared Memory​

Socket​

High Level​

Remote Procedure Call​

HTTP API​

WebSocket​

References​

• https://beej.us/guide/bgipc/
• https://en.wikipedia.org/wiki/Inter-process_communication
• https://www.youtube.com/watch?v=Y2mDwW2pMv4
• https://www.youtube.com/watch?v=83M5-NPDeWs
• https://man7.org/linux/man-pages/man2/sigaction.2.html
• https://man7.org/linux/man-pages/man3/sigqueue.3.html
• https://en.wikipedia.org/wiki/Signal_(IPC)
• https://en.wikipedia.org/wiki/Pipeline_(Unix)
• https://en.wikipedia.org/wiki/File_descriptor
• https://man7.org/linux/man-pages/man3/mkfifo.3.html
• https://man7.org/linux/man-pages/man2/mknod.2.html
• https://man7.org/linux/man-pages/man7/inode.7.html

Alocação de memória se trata de pedir ao sistema operacional por espaço de memória RAM para utilizarmos durante a execução do nosso programa.

Static Allocation​

Se refere a alocar espaço para todos os dados que já se sabe que serão necessários desdo início do seu programa.

O espaço necessário é descoberto durante a compilação de um programa e armazenado em conjunto do binário para que já seja carregada na memória na inicialização do programa.

Compilador irá identificar:

• Literais
• Variáveis estáticas/globais
• Código de Funções

Pegando o seguinte código como exemplo:

static int executions = 0;

void run(int p) {
    printf("Running");
    executions += 1;
}

int main(void) {
    run(1);
    run(5);
    run(10);
    return 0;
}

Para que seu programe funcione, o compilador consegue identificar que será necessário espaço para o literal "Running", variável estática executions e o código da função run().

A memória alocada é separada em dois segmentos:

• Data Segment
  • Variáveis estáticas
• Text Segment
  • Literais
  • Código de funções

Data segments funcionam como espaço de memória normal, onde podem ter seus valores atualizado/modificados.

Text segments são armazenados uma vez e apenas utilizados para leitura durante a execução do seu programa.

Variáveis estáticas caem na primeira categoria pois a qualquer momento podemos fazer algo como executions += 1.

Literais caem na segunda pois sempre precisaremos daquele exato literal quando o código passar por aquela linha de código printf("Running"), então não queremos que ele seja modificado de maneira nenhuma.

Código de funções são somente leitura pois estamos falando da base para se criar funções conforme o necessário. O que eu quero dizer com isto? Toda vez que executarmos uma função, utilizaremos o código da função como base para alocar memória para aquela execução da função!

Stack Allocation​

Se refere a alocar espaço na Stack.

No início do programa, um espaço na memória é reservado para dados temporários ou curto tempo de vida, este espaço reservado é chamado de Stack. Utilizar mais espaço do que o reservado irá causar Stack Overflow.

Isto é necessário pois nosso código pode se ramificar de diversas maneiras, tornando impossível descobrir toda a memória que será utilizada durante a etapa de compilação.

Pegando o seguinte código como exemplo:

int func1(int a, int b) {
    return a + b;
}

int func2(int a, int b) {
    int x = a * 3;
    int y = b * 2;
    return x + y;
}

int run(int a, int b) {
    if(a > 10) {
        return func1();
    } else {
        return func2();
    }
}

Quando uma função é chamada, o programa insere na Stack variáveis daquela função.

No caso da func1(): a, b.
No caso da func2(): a, b, x, y.

Ao sair da função, o programa remove esses valores da Stack.

É importante notar que como o espaço da Stack já foi alocada no início do programa, inserir e remover da Stack são operações rápidas.

Quando CPUs precisam de dados da memória RAM, elas pegam um bloco de dados de cada vez. O ideal é que nessa pegada já tivesse tudo que a CPU precisaria, para ajudar nisto Stacks seguem o modelo (LIFO, last-in, first-out).

Pegando a func2() como exemplo:

Podemos notar que inserimos na stack na ordem em que encontramos as variáveis, justamente para quando a CPU pegar um bloco de memória a chance de pegar tudo aumentar.

Por outro lado, note que essa arquitetura impede que nossas variáveis possam crescer de tamanho (b não poderia crescer de tamanho pois o espaço seguinte já está reservado por x), por isto os valores inseridos na Stack precisam ter tamanho fixo.

Explicit Memory Management​

Se refere a alocar espaço na Heap.

Existem casos onde precisamos que a memória possa crescer ou diminuir tamanho, justamente pois não temos como saber o quanta memória será necessária (e armazenar toda a memória RAM para si mesmo seria rude).

É importante notar que o sistema operacional é responsável por gerenciar a memória, então precisamos pedir a ele por espaço de memória RAM para utilizar.

Por exemplo, note como utilizamos a função malloc() para pedir ao sistema operacional por espaço para 3 inteiros:

int run() {
    int *v = (int*)malloc(sizeof(int) * 3);
    v[0] = 10;
    v[1] = 100;
    v[2] = 1000;
    free(v);

    return 0;
}

Fazer uma requisição por N espaços de memória ao sistema operacional, nos garante N espaço de memória, ou seja, podemos receber mais espaço de memória que o necessário (estou ignorando o caso onde a memória RAM está cheia).

Este comportamento tem como objeto minimizar a quantidade de requisições feitas ao sistema operacional por memória, pois estas requisições custam bastante tempo.

Vamos pegar outro exemplo:

int run() {
    int *v = (int*)malloc(sizeof(int) * 3);
    v[0] = 10;
    v[1] = 100;
    v[2] = 1000;
    v[3] = 10000; // New line.
    free(v);

    return 0;
}

Existe a chance deste código dar erro e a chance de não dar, tudo depende de quanta memória RAM o sistema operacional nos deu. Se ele tiver nos dado exatamente 3, um erro de Segmentation fault vai aparecer pois o sistema operacional não nos permite acessar memória RAM que ele não nos entregou.

Por outro lado, grande chance de não dar erro pois sistema operacional costumam enviar bem mais que o necessário. O seguinte código tem bem mais chance de dar erro:

int run() {
    int *v = (int*)malloc(sizeof(int) * 3);
    v[0] = 10;
    v[1] = 100;
    v[2] = 1000;
    v[3] = 10000;
    v[100000] = 100000; // New line.
    free(v);

    return 0;
}

Importante notar que v contém o endereço da memória RAM requisitada ao sistema operacional (o endereço na Heap), porém o valor de v, o endereço` é armazenado na Stack pois é uma espaço de memória fixo (um endereço tem um tamanho fixo de memória).

O grande problema que aparece com o uso da Heap é garantir que o seu programa libere a memória obtida, pois é bem comum de usuários da linguagem esquecerem de devolver a memória (free()).

Para evitar este tipo de problema, algumas técnicas para gerênciar memória foram criados:

• Garbage Collection
• Reference Counting
• Ownership Model

Garbage Collection​

É uma técnica onde toda a responsabilidade de alocar e liberar memória (malloc() e free()) é passada ao Garbage Collector, onde ele deve conseguir detectar que a memória não está mais sendo usada e libera-la.

É possível implementar um Garbage Collector em linguagens que não possuem um embutido, porém por não ser embutido, bibliotecas de terceiros podem acabar por não utiliza-lo e vazamento de memória pode acontecer de qualquer maneira.

A grande desvantagem desta técnica é que pausas no seu programa precisam ser feitas para que o Garbage Collector tenha tempo de análisar memórias que não estão mais em uso.

Reference Counting​

Nesta técnica, toda alocação de memória inclue um contador para sabermos quantas vezes aquele espaço alocado está sendo referenciado. Quando o contador chega a zero, uma chamada para liberar a memória é feita (free()).

A quantidade de referências aumenta a qualquer momento que alguém aponta para aquele espaço de memória. Por exemplo:

func _ready() -> void:
	var x = RefCounted.new()
	var y = x
	var z = [x]
	print(x.get_reference_count()) # Three
	y = null
	z = []
	print(x.get_reference_count()) # One

Cada vez que alguém referência o espaço de memória alocado por pedido da segunda linha, o contador cresce.

func _ready() -> void:
	var x = RefCounted.new()
	var y = x
	var z = [x]
	print(x.get_reference_count()) # Three
	y = null
	z = []
	print(x.get_reference_count()) # One

Cada vez que alguém para de referênciar aquele espaço de memória, o contador desce.

func _ready() -> void:
	var x = RefCounted.new()
	var y = x
	var z = [x]
	print(x.get_reference_count()) # Three
	y = x
	x = null
	print(y.get_reference_count()) # One
	y = x
	x = null
	print(y.get_reference_count()) # One

É importante notar que o contador não existe com a variável inicial, no caso x, então a qualquer momento podemos fazer com que a variável inicial deixe de referênciar e continuaremos sem problemas de usar aquela memória!

O lado negativo é que a cada referência a está variável, precisamos aumentar/diminuir o contador. O que pode ser custoso quando tem que se fazer isso para toda memória da Heap.

Ownership Model​

Diferente das maneiras anteriores onde o programador não precisa pensar sobre a liberação de memória, neste caso temos que seguir regras que no final ajudam o compilador a determinar quando que a memória deve ser liberada.

Como isto é feito durante a etapa de compilação, a execução do seu software não sofre perda de desempenho e qualquer erro relacionado ao assunto é pego durante a compilação.

A documentação da linguagem Rust deixa claro as regras:

• Cada valor possue um dono
• Valores apenas podem possuir um dono
• Quando o dono sai do escopo, o valor é liberado

References​

• https://en.wikipedia.org/wiki/Memory_management
• https://en.wikipedia.org/wiki/Stack-based_memory_allocation
• https://en.wikipedia.org/wiki/Garbage_collection_(computer_science)
• https://en.wikipedia.org/wiki/Reference_counting
• https://www.youtube.com/watch?v=N3o5yHYLviQ
• https://www.youtube.com/watch?v=ioJkA7Mw2-U
• https://doc.rust-lang.org/book/ch04-01-what-is-ownership.html

The Elm Architecture​

(MVU, Model-View-Update)

A arquitetura se resume a 3 partes:

• Model: Conjuntos de dados sobre o estado da aplicação
• View: Converte os dados do model para algo visual
• Update: Reage a atualizações para atualizar os dados do model

Seja qual for a sua aplicação (CLI, TUI, GUI, ...), ela é responsável por receber o que o usuário deve visualizar e por notificar atualizações vindas do usuário:

Bubbletea​

É responsável por rodar em loop a arquitetura Elm. Todo o código para isto se resume a:

package main

import tea "github.com/charmbracelet/bubbletea"

func main() {
    program := tea.NewProgram(
        MyStruct{} // Here you pass your model.
    )

    _, err := program.Run()

    if err != nil {
        print(err.Error())
    }
}

Entenda que Model é terminologia para representar uma coleção de dados e é por isto que Bubbletea utiliza structs para representar models.

Models Structure​

Models dentro do Bubbletea devem seguir a seguinte estrutura:

type MyStruct struct {
    // Fields.
}

func (m MyStruct) Init() tea.Cmd {
    // Run on initialization.
}

func (m MyStruct) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    // Process a message.
}

func (m MyStruct) View() string {
    // Write to screen.
}

Podemos ver que é dividido em 4 partes:

• Uma struct responsável por representar o Model da arquitetura Elm
• Um método Init() único da estrutura bubbletea
• Um método Update() responsável por representar o Update da arquitetura Elm
• Um método View() responsável por representar o View da arquitetura Elm

func newMyStruct() MyStruct {
    return MyStruct{
        // Set default fields values here
    }
}

func main() {
    program := tea.NewProgram(newMyStruct()) // Use here
}

Keys​

Teclas pressionadas no teclado vão para o mesmo lugar que todas interações (Update()), lá resta a você reconhecer como sendo um pressionamento de tecla.

func (m MyStruct) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        if msg.String() == "ctrl+c" {
            return m, tea.Quit
        }
    }

    return m, nil
}

No exemplo podemos ver que possuimos um switch para nos ajudar a identificar o tipo da mensagem, isso é necessário pois a mensagem pode ter qualquer tipo (não necessariamente uma mensagem de pressionamento de tecla).

Mensagens de teclas dentro do Bubbletea podem ser convertido para strings, o que nos da uma string de fácil entedimento porém nem sempre uma ação está ligada a apenas um atalho, então pode ser útil sabermos como ligar diversos atalhos a uma ação:

var quit = key.NewBinding(
    key.WithKeys("ctrl+c", "ctrl+q", "q")
)

// ...

func (m MyStruct) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch {
        case key.Matches(msg, quit):
            return m, tea.Quit
        }
    }

    return m, nil
}

var keyMap struct {
    Up   key.Binding
    Down key.Binding
    Quit key.Binding
}

var keys = keyMap{
    Up: key.NewBinding(
        key.WithKeys("up", "w"),
    ),
    Down: key.NewBinding(
        key.WithKeys("down", "s"),
    ),
    Quit: key.NewBinding(
        key.WithKeys("ctrl+c", "ctrl+q", "q"),
    ),
}

// ...

func (m MyStruct) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    switch msg := msg.(type) {
    case tea.KeyMsg:
        switch {
        case key.Matches(msg, keys.Quit):
            return m, tea.Quit
        case key.Matches(msg, keys.Down):
            // Do something
        case key.Matches(msg, keys.Up):
            // Do something
    }

    return m, nil
}

Bubbles​

É uma coleção de models com parte da lógica já preparada.

Olhando a assinatura das funções e structs do spinner, podemos ver que ele implementa:

• Model: type Model struct
• Update: func (m Model) Update(msg tea.Msg) (Model, tea.Cmd)
• View: func (m Model) View() string

Ele implementa quase todas as partes necessárias para ser executado diretamente no Bubbletea, a única parte que está faltando é Init(). Por que isso?

Acontece que spinner não tem intenção de ser um modelo perfeito para ser utilizado diretamente pelo Bubbletea, pois não faz sentido criar um programa Bubbletea que apenas exibe um spinner.

Porém podemos criar nosso próprio model que utiliza este spinner:

type MyStruct struct {
	spinner spinner.Model
}

func newSpinner() MyStruct {
	return MyStruct{
		spinner: spinner.New(),
	}
}

func (m MyStruct) Init() tea.Cmd {
	return m.spinner.Tick // spinner requires this to start
}

func (m MyStruct) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
	var cmd tea.Cmd

	switch msg := msg.(type) {
	case tea.KeyMsg:
		if msg.String() == "ctrl+c" {
			return m, tea.Quit
		}
	default:
		m.spinner, cmd = m.spinner.Update(msg)
	}

	return m, cmd
}

func (m MyStruct) View() string {
	return m.spinner.View()
}

func main() {
    program := tea.NewProgram(
        MyStruct{
            spinner: spinner.New(),
        }
    )

    _, err := program.Run()

    if err != nil {
        print(err.Error())
    }
}

Note como basicamente reutilizamos tudo do spinner para fazer nosso model:

• Nossa struct é o spinner sozinho
• Nossa View() apenas chama a View() do spinner
• Nosso Update() chama Update() do spinner e detecta se o atalho para sair foi pressionado

Como podemos ver os componentes do Bubbles foram feitos para serem utilizados pelos seus models (e não pelo Bubbletea diretamente). Imagine o susto de alguém executando o spinner diretamente e ele nunca fechando pois ninguém processa ctrl+c para sair.

References​

• https://guide.elm-lang.org/architecture/
• https://github.com/charmbracelet/bubbletea
• https://github.com/charmbracelet/bubbles
• https://www.youtube.com/watch?v=5lxQJS3b38w
• https://www.youtube.com/watch?v=ERaZi0YvBRs

1 - Performance​

Mude o modo de renderização para Compatibility, não é como se você fosse precisar de qualquer renderização além do básico para desenhar uma janela na tela.

Ative Application > Run > Low Processor Mode para que tenha um delay entre as renderizações da janela e apenas renderizar se alguma mudança for detectada. Em jogos a tela muda constantemente, então esse tipo de delay e validação só atrapalham mas como estamos falando de GUI que altera bem menos, isto ajuda muito.

2 - Window Title Bar​

Por padrão o nosso sistema operacional nos providência o gráfico básico de uma janela e nos deixa responsável por desenhar o conteúdo dentro dela.

O lado positivo é que isto nos providência o básico de uma janela, como aqueles 3 botões no topo da direita (minimizar, máximizar, fechar, ...).

Porém note que, dependendo do sistema operacional, mais opções podem estar disponíveis! Se eu clicar com o botão direito na title bar do topo, podemos ver mais ações:

Se ativarmos Display > Window > Size > Borderless, o sistema operacional deixará de adicionar a title bar no topo:

Basicamente ele está assumindo que você mesmo irá desenhar a title bar no topo caso queira (normalmente em jogos isto não faz sentido).

3 - Multiple Windows​

Janelas abertas são tratadas como processos filhos, ou seja, o encerramento de uma janela pai irá encerrar os filhos.

Caso queiramos ter múltiplas janelas idênticas, igual a editores de textos e navegadores, precisamos ter certeza que a janela principal (processo inicial) não possa ser encerrado da maneira padrão (clickando no botão de fechar).

Podemos resolver isto escondendo a janela principal e apenas exibindo as subwindows.

Ative Display > Window > Size > Transparent para que o fundo cinza padrão não seja renderizado durante a execução.

Ative Display > Window > Per Pixel Transparency > Allowed para que o fundo realmente seja transparente (caso contrário vai ficar o canvas preto).

Como visto na sessão anterior...

Ative Display > Window > Size > Borderless para o sistema operacional deixará de adicionar a title bar no topo.

Embora ela esteja transparente, ela ainda é uma janela como as outras. Podemos conferir que ela ainda aparece quando apertando Alt+Tab (ou apenas apertando Alt no Ubuntu).

Agora nós temos que tratar inputs!

Primeiro podemos notar que se está janela for posta na frente de outra, ela não irá deixar de consumir os seus clicks (mesmo que você queira selecionar algo na janela de trás).

Para resolver isto podemos alterar janela raiz (criada quando seu programa inicia) para repassar adiante clicks do mouse.

func _ready() -> void:
	get_window().mouse_passthrough = true

Segundo podemos notar que ela ainda está processando teclas (pode ser selecionada pelo Alt + Tab, fechada por Alt + F4, maximizada com Super + Up, etc).

Ative Display > Window > Size > No Focus para que ela não possa ser focada (até por atalhos).

Lembre que fechar o processo pai fecha todos os filhos, porém fechar todos os filhos não fecha o pai.

Isto quer dizer que o processo pai continua rodando mesmo se o usuário fechar todas as janelas filhas. Agora o usuário apenas conseguiria encerrar o programa pelo "gerenciador de tarefas" ou terminal.

Para tratar isto podemos ligar um signal a um método responsável por notar quando a quantidade de filhos mudar e encerrar o programa se necessário.

func _on_child_order_changed() -> void:
	if get_child_count() == 0:
		get_tree().quit()

Agora precisamos entender que cada janela aberta é uma subwindow. Existem dois tipos de subwindows:

1. Subwindows
   • Quando sua janela pede ao sistema operacional para criar uma janela filha dela
   • Sua janela filha vai possuir a title bar padrão de janelas
2. Embed subwindows
   • Quando sua janela simula outra janela dentro dela mesmo
   • Isto impossibilita ela de ser mover para fora da janela pai

Se estamos tratando de uma aplicação que possui múltiplas janelas, precisamos que ela se mova para fora da janela pai. Caso contrário isso ocorreria:

A janela 2 está saindo do limite da janela pai.

Poderiamos inicializar a janela pai maximizada para evitar isto porém outros problemas iriam aparecer, por exemplo: Janela pai ignorar clicks e teclas, tornando impossível interagir com as janelas simuladas nele.

Desative Display > Window > Subwindows > Embed Subwindows para que as subwindows sejam tratadas como janelas reais pelo sistema operacional (em vez de simuladas pela janela pai).

Mas se quisermos ter uma title bar de janela única para as nossas janelas? Podemos fazer o mesmo que fizemos com janela principal, torna-la borderless.

Dentro das propriedades da Janela, ative Flags > Borderless.

Agora nós seriamos responsáveis por criar a title bar no topo da janela. Desta maneira poderiamos fazer uma title bar única igual ao Google Chrome ou Steam!

4 - Custom Title Bar​

Ter uma title bar própria é relativamente raro hoje em dia, pois muitas vezes requer reinventar a roda sem trazer benifícios reais.

Mas isto não quer dizer que nenhuma aplicação faz isto:

_{(Steam, GNOME Files, Google Chrome)}

Note que as 3 aplicações aproveitaram o espaço para providênciar mais informações e funcionalidades ao usuário. Porém nós vamos focar em pelo menos reproduzir o básico:

1. Exibir titulo
2. Providênciar botões de minimizar, maximizar e fechar
3. Double click maximizar
4. Arrastar a title bar deve mover a janela
5. Redimensionar janela se arrastar as bordas

Depois disso você deve ser capaz de adicionar ou remover mais utilidades conforme a sua vontade.

Exibir Titulo​

Basta utilizar o node Label.

Minimize, Maximize, Close Buttons​

Basta utilizar 3 nodes Button tratando o signal pressed:

func _on_minimize_pressed() -> void:
	get_window().mode = Window.MODE_MINIMIZED


func _on_maximize_pressed() -> void:
	if get_window().mode == Window.MODE_MAXIMIZED:
		get_window().mode = Window.MODE_WINDOWED
	else:
		get_window().mode = Window.MODE_MAXIMIZED


func _on_close_pressed() -> void:
	get_tree().quit()

Double Click Maximize​

Container não possui signal para isto diretamente porém podemos utilizar o signal mais geral gui_input.

func _on_minimize_pressed() -> void:
	...


func _on_maximize_pressed() -> void:
	...


func _on_close_pressed() -> void:
	...


func _on_title_bar_gui_input(event: InputEvent) -> void:
	if event is InputEventMouseButton:
		_on_title_bar_mouse_button(event)


func _on_title_bar_mouse_button(event: InputEventMouseButton) -> void:
	if event.button_index == MOUSE_BUTTON_LEFT and event.double_click:
		_on_title_bar_double_click()


func _on_title_bar_double_click() -> void:
	match get_window().mode:
		Window.MODE_MAXIMIZED:
			get_window().mode = Window.MODE_WINDOWED
		_:
			get_window().mode = Window.MODE_MAXIMIZED

Já estamos dividindo em funções menores pois os passos seguintes irão adicionar mais funcionalidades nestas funções gerais.

Drag Window​

A princípio, arrastar a janela pode ser resumido em saber duas coisas:

• Saber se o click do mouse está sendo pressionado
• Onde que o click estava quando começou

var _title_bar_dragging: bool = false

var _title_bar_dragging_start: Vector2i


func _on_minimize_pressed() -> void:
	...


func _on_maximize_pressed() -> void:
	...


func _on_close_pressed() -> void:
	...


func _on_title_bar_gui_input(event: InputEvent) -> void:
	if event is InputEventMouseButton:
		_on_title_bar_mouse_button(event)
	elif event is InputEventMouseMotion:
		_on_title_bar_mouse_motion(event)


func _on_title_bar_mouse_button(event: InputEventMouseButton) -> void:
	if event.button_index == MOUSE_BUTTON_LEFT and event.double_click:
		_on_title_bar_double_click()
	elif event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
		_title_bar_dragging = true
		_title_bar_dragging_start = get_global_mouse_position()
	elif event.button_index == MOUSE_BUTTON_LEFT and not event.pressed:
		_title_bar_dragging = false


func _on_title_bar_double_click() -> void:
	...


func _on_title_bar_mouse_motion(_event: InputEventMouseMotion) -> void:
	if _title_bar_dragging:
		_on_title_bar_dragged()


func _on_title_bar_dragged() -> void:
	match get_window().mode:
		Window.MODE_WINDOWED:
			get_window().position += get_global_mouse_position() as Vector2i - _title_bar_dragging_start

func _ready() -> void:
	get_window().move_to_center()

Esse foi apenas o essencial sobre arrastar, agora podemos pensar em implementar detalhes sobre a ação de arrastar janelas.

Por exemplo: Quando o usuário tentar arrastar uma janela máximizada, ela automaticamente sai do máximizado e se posiciona para que o mouse esteja proporcionalmente na posição correta.

var _title_bar_dragging: bool = false

var _title_bar_dragging_start: Vector2i

var _title_bar_dragging_adjustment: float = 0


func _on_minimize_pressed() -> void:
	...


func _on_maximize_pressed() -> void:
	...


func _on_close_pressed() -> void:
	...


func _on_title_bar_gui_input(event: InputEvent) -> void:
	...


func _on_title_bar_mouse_button(event: InputEventMouseButton) -> void:
	...


func _on_title_bar_double_click() -> void:
	...


func _on_title_bar_mouse_motion(event: InputEventMouseMotion) -> void:
	...


func _on_title_bar_dragged() -> void:
	match get_window().mode:
		Window.MODE_WINDOWED:
			get_window().position += get_global_mouse_position() as Vector2i - _title_bar_dragging_start
		Window.MODE_MAXIMIZED:
			_title_bar_dragging_adjustment = get_global_mouse_position().x / get_window().size.x
			get_window().mode = Window.MODE_WINDOWED


func _on_resized() -> void:
	if _title_bar_dragging_adjustment != 0:
		get_window().position += (get_global_mouse_position() as Vector2i)
		get_window().position.x -= get_window().size.x * _title_bar_dragging_adjustment
		_title_bar_dragging_start = get_global_mouse_position()
		_title_bar_dragging_adjustment = 0

Resize Window (old)​

Redimensionar pode ser facilmente implementado se utilizarmos o node MarginContainer que nos permite adicionar bordas às laterais, estas serão nossas bordas que devem reagir ao mouse.

Nodes do tipo Control possuem lógica para lidar com inputs do mouse, eles podem consumir ou passar ao node de cima as input do mouse.

Isso quer dizer que qualquer input do mouse na nossa janela (que não tiver sido consumida) chegará ao nosso MarginContainer. Isto não é o que queremos, para nós só é interessante que chegue inputs interagindo com a borda do nosso container.

Podemos resolver isto parando o consumo de inputs no container logo abaixo do MarginContainer:

Agora temos certeza que interações vindo do signal gui_input são interações diretas com o MarginContainer.

enum Margin {
	NONE,
	TOP,
	RIGHT,
	BOTTOM,
	LEFT,
	TOP_RIGHT,
	TOP_LEFT,
	BOTTOM_RIGHT,
	BOTTOM_LEFT,
}

var _margin_dragging: bool = false

var _margin_dragging_edge_start: Vector2i

var _margin_dragging_origin_limit: Vector2i

var _margin_selected: Margin

var _title_bar_dragging: bool = false

var _title_bar_dragging_start: Vector2i

var _title_bar_dragging_adjustment: float = 0

func _get_current_margin(mouse_position: Vector2) -> Margin:
	var margin: Margin = Margin.NONE
	
	if get_global_mouse_position().x < get_theme_constant("margin_left"):
		margin = Margin.LEFT
	elif get_global_mouse_position().x > size.x - get_theme_constant("margin_right"):
		margin = Margin.RIGHT
	
	if get_global_mouse_position().y < get_theme_constant("margin_top"):
		match margin:
			Margin.LEFT:
				return Margin.TOP_LEFT
			Margin.NONE:
				return Margin.TOP
			Margin.RIGHT:
				return Margin.TOP_RIGHT
	elif get_global_mouse_position().y > size.y - get_theme_constant("margin_bottom"):
		match margin:
			Margin.LEFT:
				return Margin.BOTTOM_LEFT
			Margin.NONE:
				return Margin.BOTTOM
			Margin.RIGHT:
				return Margin.BOTTOM_RIGHT
	
	return margin


func _on_gui_input(event: InputEvent) -> void:
	if event is InputEventMouseButton:
		_on_mouse_button(event)
	elif event is InputEventMouseMotion:
		_on_mouse_motion(event)


func _on_mouse_button(event: InputEventMouseButton) -> void:
	if event.button_index == MOUSE_BUTTON_LEFT and event.pressed:
		_margin_dragging = true
		_margin_selected = _get_current_margin(event.position)
		_margin_dragging_edge_start = get_window().position + get_window().size
		_margin_dragging_origin_limit = _margin_dragging_edge_start - get_window().min_size
	elif event.button_index == MOUSE_BUTTON_LEFT and not event.pressed:
		_margin_dragging = false


func _on_mouse_motion(event: InputEventMouseMotion) -> void:
	if _margin_dragging:
		_on_dragged(event)
	else:
		_on_hover(event)


func _on_dragged(event: InputEventMouseMotion) -> void:
	if get_window().mode != Window.MODE_WINDOWED:
		return
	
	match _margin_selected:
		Margin.TOP:
			get_window().position.y = min(
				get_window().position.y + event.position.y,
				_margin_dragging_origin_limit.y
			)
			
			get_window().size.y = _margin_dragging_edge_start.y - get_window().position.y
		Margin.RIGHT:
			get_window().size.x = event.position.x
		Margin.BOTTOM:
			get_window().size.y = event.position.y
		Margin.LEFT:
			get_window().position.x = min(
				get_window().position.x + event.position.x,
				_margin_dragging_origin_limit.x
			)
			
			get_window().size.x = _margin_dragging_edge_start.x - get_window().position.x
		Margin.TOP_RIGHT:
			get_window().position.y = min(
				get_window().position.y + event.position.y,
				_margin_dragging_origin_limit.y
			) # Top
			
			get_window().size = Vector2i(
				event.position.x, # Right
				_margin_dragging_edge_start.y - get_window().position.y, # Top
			)
		Margin.TOP_LEFT:
			get_window().position = Vector2i(
				min(
					get_window().position.x + event.position.x,
					_margin_dragging_origin_limit.x
				), # Left,
				min(
					get_window().position.y + event.position.y,
					_margin_dragging_origin_limit.y
				), # Top
			)

			get_window().size = Vector2i(
				_margin_dragging_edge_start.x - get_window().position.x, # Left
				_margin_dragging_edge_start.y - get_window().position.y, # Top
			)
		Margin.BOTTOM_RIGHT:
			get_window().size = Vector2i(
				event.position.x, # Right
				event.position.y, # Bottom
			)
		Margin.BOTTOM_LEFT:
			get_window().position.x += event.position.x # Left
			get_window().size = Vector2i(
				_margin_dragging_edge_start.x - get_window().position.x, # Left
				event.position.y, # Bottom
			)


func _on_hover(event: InputEventMouseMotion) -> void:
	match _get_current_margin(event.position):
		Margin.NONE:
			mouse_default_cursor_shape = Control.CURSOR_ARROW
		Margin.TOP:
			mouse_default_cursor_shape = Control.CURSOR_VSIZE
		Margin.RIGHT:
			mouse_default_cursor_shape = Control.CURSOR_HSIZE
		Margin.BOTTOM:
			mouse_default_cursor_shape = Control.CURSOR_VSIZE
		Margin.LEFT:
			mouse_default_cursor_shape = Control.CURSOR_HSIZE
		Margin.TOP_RIGHT:
			mouse_default_cursor_shape = Control.CURSOR_BDIAGSIZE
		Margin.TOP_LEFT:
			mouse_default_cursor_shape = Control.CURSOR_FDIAGSIZE
		Margin.BOTTOM_RIGHT:
			mouse_default_cursor_shape = Control.CURSOR_FDIAGSIZE
		Margin.BOTTOM_LEFT:
			mouse_default_cursor_shape = Control.CURSOR_BDIAGSIZE


func _on_minimize_pressed() -> void:
	...


func _on_maximize_pressed() -> void:
	...


func _on_close_pressed() -> void:
	...


func _on_title_bar_gui_input(event: InputEvent) -> void:
	...


func _on_title_bar_mouse_button(event: InputEventMouseButton) -> void:
	...


func _on_title_bar_double_click() -> void:
	...


func _on_title_bar_mouse_motion(_event: InputEventMouseMotion) -> void:
	...


func _on_title_bar_dragged() -> void:
	...


func _on_resized() -> void:
	...