Instalar e usar o Alibaba Cloud Compiler para criar aplicações C++ de alto desempenho - Alibaba Cloud Linux: Central de Documentação do Alibaba Cloud

Informações básicas

Em comparação com o GNU Compiler Collection (GCC) e outras versões do Clang/LLVM, o Alibaba Cloud Compiler oferece melhorias significativas nas velocidades de compilação e build.
- O Alibaba Cloud Compiler adota técnicas diferentes, como otimização guiada por perfil (PGO), para acelerar a compilação e processar código C++ em grande escala mais rapidamente do que outros compiladores, como o GCC.
- O linker do Clang/LLVM (LLD) supera o linker GNU usado pelo GCC, especialmente no processamento de arquivos binários grandes.
- O Alibaba Cloud Compiler suporta C++20 Modules e permite modularizar uma biblioteca padrão C++ em std-module. Use std-module para transformar o código de negócios com baixo custo e acelerar a compilação.
O Alibaba Cloud Compiler utiliza tecnologias como ThinLTO e AutoFDO para melhorar o desempenho dos programas. Ele executa em diferentes arquiteturas, como x86 e Arm64, e é ajustado para processadores YiTian 710, aumentando ainda mais o desempenho.
O Alibaba Cloud Compiler suporta Coroutines e Modules, além de fornecer bibliotecas padrão modularizadas. A Alibaba Cloud disponibiliza o yaLanTingLibs, que inclui componentes comuns para desenvolvedores C++, como biblioteca de corrotinas, biblioteca de serialização, biblioteca de Remote Procedure Call (RPC) e recursos HTTP.

Nota
O yaLanTingLibs é um conjunto de bibliotecas utilitárias C++ modernas e de alto desempenho, fáceis de usar, que ajudam os desenvolvedores a criar aplicações C++ eficientes.

Pré-requisitos

Crie uma instância do Elastic Compute Service (ECS) executando o Alibaba Cloud Linux 3. Para mais informações, consulte Criar uma instância.

Nota

O Alibaba Cloud Compiler suporta apenas o Alibaba Cloud Linux 3.

Instalar e usar o Alibaba Cloud Compiler

Instale o Alibaba Cloud Compiler.

sudo yum install -y alibaba-cloud-compiler

Instale o pacote libstdc++-devel.

O pacote libstdc++-devel fornece os arquivos de cabeçalho da GNU Standard C++ Library.
```
sudo yum -y install libstdc++-devel
```

Importe as variáveis de ambiente.

export PATH=/opt/alibaba-cloud-compiler/bin:$PATH

Use o Alibaba Cloud Compiler para compilação.

Compilação simples

Crie o arquivo hello.cpp.
```
sudo vim hello.cpp
```
Pressione a tecla i para entrar no modo de inserção e copie e cole o seguinte conteúdo no arquivo:
```
#include <iostream>
int main() {
  std::cout << "hello C++" << std::endl;
  return 0;
}
```
Pressione a tecla Esc, insira :wq e pressione a tecla Enter para salvar e fechar o arquivo.
Compile o código C++ modularizado.
```
clang++ -O2 hello.cpp -o hello.cpp.out
```
Execute o programa.
```
./hello.cpp.out
```
A saída do comando abaixo indica que o programa foi executado com sucesso.

Usar C++20 Coroutines e Modules

O Alibaba Cloud Compiler suporta C++20 Coroutines e Modules, recursos que ajudam a melhorar a eficiência da compilação e o desempenho. Para ver exemplos de corrotinas, consulte Usar a biblioteca RPC e Usar a biblioteca HTTP.

Nota

Nas chamadas de função tradicionais, uma função executa até a conclusão após ser chamada. As corrotinas são um conceito de programação que permite suspender e retomar a execução de funções. Esse mecanismo flexível de fluxo de controle simplifica a implementação de padrões de programação assíncrona e geradores.
No paradigma tradicional de programação C++, o código organiza-se em arquivos de cabeçalho (.h/.hpp) e arquivos de origem (.cpp), sendo que os arquivos de cabeçalho contêm as declarações. Você faz declarações em um arquivo de cabeçalho e usa a diretiva de pré-processador #include para inserir uma cópia desse cabeçalho em cada arquivo de origem que precise das declarações. Consequentemente, os compiladores podem analisar repetidamente os mesmos arquivos de cabeçalho, o que torna a compilação mais lenta. Os Modules surgem como um método para melhorar a organização do código e a eficiência da compilação.

Ao usar o Clang para compilar programas C++, configure os parâmetros listados na tabela a seguir.

Parâmetro	Descrição
`-std=`	Especifica o padrão da linguagem C++ usado na compilação. Se você definir `-std=c++20`, os recursos C++ Coroutines e Modules serão ativados.
`--precompile`	Compila unidades de módulo em arquivos de interface de módulo binário (BMI).
`-fprebuilt-module-path`	Define o caminho para busca de arquivos BMI.
`-fstd-modules`	Indica a compilação de arquivos para módulos std.
`-fmodules-export-all`	Marca todas as declarações nos módulos atuais como `export`.
`-fmodules-export-macros`	Permite que os módulos exportem macros.
`-try-load-bmi-when-preprocessing`	Busca arquivos BMI durante o pré-processamento.
`-fstd-module-path`	Define o caminho para busca de módulos std.
`-fcoro-aligned-allocation`	Prioriza alocação alinhada para C++ Coroutines.

Exemplo de compilação:

Crie o arquivo Hello.cppm.
```
sudo vim Hello.cppm
```

Pressione a tecla i para entrar no modo de inserção e copie e cole o seguinte conteúdo no arquivo:

module;
#include <iostream>
export module Hello;
export void hello() {
  std::cout << "Hello World!\n";
}

Pressione a tecla Esc, insira :wq e pressione a tecla Enter para salvar e fechar o arquivo.
Crie o arquivo use.cpp.
```
sudo vim use.cpp
```
Pressione a tecla i para entrar no modo de inserção e copie e cole o seguinte conteúdo no arquivo:
```
import Hello;
int main() {
  hello();
  return 0;
}
```
Pressione a tecla Esc, insira :wq e pressione a tecla Enter para salvar e fechar o arquivo.

Compile o código C++ modularizado.

# Precompile the module interface to create the Hello.pcm file.
clang++ -std=c++20 Hello.cppm --precompile -o Hello.pcm
# Compile the main program and link the module to create the executable Hello.out file.
clang++ -std=c++20 use.cpp -fprebuilt-module-path=. Hello.pcm -o Hello.out

Execute o programa.
```
./Hello.out
```
A saída do comando abaixo confirma a execução do programa.

(Opcional) Usar o yaLanTingLibs

Use o yaLanTingLibs, que fornece biblioteca de corrotinas, biblioteca de serialização, biblioteca RPC e recursos HTTP baseados em C++20 Coroutines e na funcionalidade de metaprogramação de templates do C++. Para mais informações, visite yalantinglibs e async_simple.

A biblioteca de serialização serve para serializar e desserializar dados. Serialização é o processo de converter uma estrutura de dados ou estado de objeto em um formato armazenável em arquivos ou buffers, ou transmissível por redes. A desserialização restaura a estrutura de dados ou o estado do objeto transmitido ou armazenado à sua forma original.
RPC é uma biblioteca usada para comunicação entre processos (IPC). Ela permite que programas C++ executem funções ou métodos em uma máquina remota como se fossem locais. O RPC abstrai detalhes como transmissão de rede, serialização, desserialização e rotas, permitindo que os desenvolvedores foquem na lógica de negócios de suas aplicações.
HTTP é um protocolo de camada de aplicação para sistemas de informação hipermídia distribuídos e colaborativos. A biblioteca coro_http é uma solução HTTP de alto desempenho e fácil uso, implementada com corrotinas C++20. Ela inclui um servidor HTTP e um cliente HTTP para ajudar os usuários a desenvolver aplicações HTTP rapidamente.

Instale o yaLanTingLibs.
```
sudo yum install -y yalantinglibs-devel
```

Use as bibliotecas de serialização, RPC e HTTP do yaLanTingLibs.

Usar a biblioteca de serialização

Crie o arquivo test.cpp.
```
sudo vim test.cpp
```

Pressione a tecla i para entrar no modo de inserção e copie e cole o seguinte conteúdo no arquivo:

#include <iostream>
#include "ylt/struct_pack.hpp"
struct person {
  int age;
  std::string name;
};
int main() {
  person tom{.age=20,.name="tom"};
  auto buffer = struct_pack::serialize(tom);
  auto tom2 = struct_pack::deserialize<person>(buffer);
  std::cout<<"age: "<<tom2.value().age<<", name: "<<tom2.value().name<<std::endl;
  return 0;
}

Pressione a tecla Esc, insira :wq e pressione a tecla Enter para salvar e fechar o arquivo.
Compile o programa.
```
clang++ test.cpp -std=c++20 -o test
```
Execute o programa.
```
./test
```
A saída do comando abaixo mostra que o programa foi executado.

Usar a biblioteca RPC

Crie o arquivo server.cpp em um servidor.
```
sudo vim server.cpp
```

Pressione a tecla i para entrar no modo de inserção e copie e cole o seguinte conteúdo no arquivo:

#include "ylt/coro_rpc/coro_rpc_server.hpp"
std::string ping(std::string ping) {
 return "Receive: " + ping + ". Return pong.";
}
int main() {
 coro_rpc::coro_rpc_server server{1 , 8801};
 server.register_handler<ping>();
 return server.start();
}

Pressione a tecla Esc, insira :wq e pressione a tecla Enter para salvar e fechar o arquivo.
Crie o arquivo client.cpp.
```
sudo vim client.cpp
```

Pressione a tecla i para entrar no modo de inserção e copie e cole o seguinte conteúdo no arquivo:

#include <iostream>
#include "ylt/coro_rpc/coro_rpc_client.hpp" 
std::string ping(std::string);
async_simple::coro::Lazy<void> example(){
    coro_rpc::coro_rpc_client client;
    auto ec = co_await client.connect("localhost","8801");
    assert(!ec);
    auto ret = co_await client.call<ping>("ping");
    std::cout << ret.value() << std::endl;
    co_return;
};
int main(){
    async_simple::coro::syncAwait(example());
    return 0;
}

Pressione a tecla Esc, insira :wq e pressione a tecla Enter para salvar e fechar o arquivo.

Compile o programa do lado do servidor.

clang++ server.cpp  -I /usr/include/ylt/thirdparty -std=c++20  -o server -lpthread

Compile o programa do lado do cliente.

Nota
Antes de compilar o programa do cliente, certifique-se de que o Alibaba Cloud Compiler esteja instalado e que as variáveis de ambiente tenham sido importadas no cliente. Para mais informações, consulte Compilação com Alibaba Cloud Compiler.
```
clang++ client.cpp  -I /usr/include/ylt/thirdparty -std=c++20  -o client -lpthread
```
Execute o seguinte comando no servidor e no cliente para iniciá-los:
```
./server & ./client
```
O sistema retorna a saída de comando abaixo. As entradas de log descrevem todo o processo, incluindo o início do servidor RPC, a escuta de solicitações RPC pelo servidor, o envio de solicitações pelo cliente RPC, o processamento dessas solicitações pelo servidor e o fechamento da conexão pelo cliente.

Usar a biblioteca HTTP

Crie o arquivo http.cpp em um servidor.
```
sudo vim http.cpp
```

Pressione a tecla i para entrar no modo de inserção e copie e cole o seguinte conteúdo no arquivo:

#include <iostream>
  
#include "ylt/coro_http/coro_http_client.hpp"
#include "ylt/coro_http/coro_http_server.hpp"

using namespace std::chrono_literals;
using namespace coro_http;

async_simple::coro::Lazy<void> basic_usage() {
  coro_http_server server(1, 9001);
  server.set_http_handler<GET>(
      "/get", [](coro_http_request &req, coro_http_response &resp) {
        resp.set_status_and_content(status_type::ok, "ok");
      });

  server.async_start();
  std::this_thread::sleep_for(300ms);

  coro_http_client client{};
  auto result = co_await client.async_get("http://127.0.0.1:9001/get");
  assert(result.status == 200);
  assert(result.resp_body == "ok");
  for (auto [key, val] : result.resp_headers) {
    std::cout << key << ": " << val << "\n";
  }
}

int main() {
  async_simple::coro::syncAwait(basic_usage());
}

Pressione a tecla Esc, insira :wq e pressione a tecla Enter para salvar e fechar o arquivo.

Compile o programa HTTP.

clang++ http.cpp -I /usr/include/ylt/thirdparty -std=c++20 -o http -lpthread

Execute o programa HTTP.
```
./http
```
A saída do comando abaixo indica que o programa foi executado.