Xmake é uma ferramenta leve de construção multiplataforma baseada em Lua.
É muito leve e não possui dependências porque possui um tempo de execução Lua integrado.
Ele usa xmake.lua para manter a construção do projeto. Comparado com makefile/CMakeLists.txt, a sintaxe de configuração é mais concisa e intuitiva, e é muito amigável para iniciantes. Pode começar rapidamente em pouco tempo, permitindo que os usuários se concentrem mais no desenvolvimento real do projeto.
Podemos usá-lo para compilar projetos diretamente como Make/Ninja ou gerar arquivos de projeto como CMake/Meson Além disso, possui um sistema de gerenciamento de pacotes integrado para ajudar os usuários a resolver o uso integrado de bibliotecas dependentes de C/C++.
Atualmente, o Xmake é usado principalmente para a construção de projetos C/C++, mas também suporta a construção de outras linguagens nativas, que podem realizar compilação mista com C/C++, e a velocidade de compilação também é muito rápida, que pode ser igual para Ninja.
Xmake = Build backend + Project Generator + Package Manager + [Remote|Distributed] Build + Cache
Apesar de não ser muito preciso, ainda podemos entender o Xmake da seguinte forma:
Xmake ~= Make/Ninja + CMake/Meson + Vcpkg/Conan + distcc + ccache/sccache
Introdução de novos recursos
Nesta versão, adicionamos uma tonelada de novos recursos pesados:
- Suporte de compilação distribuída
- Cache de compilação local integrado
- Suporte a cache de compilação remota
Com esses recursos, podemos compilar grandes projetos C/C++ muito mais rapidamente. Além disso, eles são completamente multiplataforma, suportam não apenas gcc/clang, mas também msvc, e não há dependência de terceiros, exceto o compilador, que é muito conveniente de usar.
Portanto, usar o Xmake é equivalente a usá-lo ao mesmo tempo . distcc/ccache/sccache
Comparado com essas ferramentas de terceiros, o Xmake oferece suporte total ao Windows e ao msvc, o que elimina diferenças de plataforma, chamadas de processo independentes e a sobrecarga de processos de daemon adicionais.
Além desses recursos, a nova versão do Xmake também adiciona suporte de compilação para projetos Keil/c51, bem como suporte para os compiladores nvc/nvc++/nvfortran na cadeia de ferramentas nvidia-hpc-sdk.
A compilação remota oferece suporte à autenticação do usuário
Na última versão, inicialmente suportamos a compilação remota, mas não fornecíamos suporte à autenticação do usuário, o que traria alguns problemas de segurança, por isso, nesta versão, adicionamos o suporte à autenticação do usuário.
Atualmente, o Xmake fornece principalmente os seguintes mecanismos de autenticação: além disso, também é eficaz para compilação distribuída e cache remoto.
- Autenticação de token
- Autenticação de senha
- Verificação de host confiável
Autenticação de token
Esse também é o método recomendado padrão, que é mais seguro, mais conveniente para configurar e conectar e não precisa digitar uma senha toda vez que você se conectar.
Quando executamos o comando, um arquivo de configuração de servidor e cliente será gerado por padrão, e um token padrão será gerado automaticamente, portanto, a conexão direta local não requer nenhuma configuração. xmake service
Configuração de autenticação do servidor
O servidor pode ser configurado com vários tokens para autorizar conexões com diferentes hosts de usuários e, é claro, pode compartilhar um token.
$ cat ~/.xmake/service/server.conf
{
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
remote_build = {
listen = "0.0.0.0:9691",
workdir = "/Users/ruki/.xmake/service/server/remote_build"
},
tokens = {
"e438d816c95958667747c318f1532c0f"
}
}
Configuração de autenticação do cliente
O cliente só precisa adicionar o token no servidor à configuração do cliente correspondente.
$ cat ~/.xmake/service/client.conf
{
remote_build = {
connect = "127.0.0.1:9691",
token = "e438d816c95958667747c318f1532c0f"
}
}
Gerar novo token manualmente
Também podemos executar o seguinte comando para gerar manualmente um novo token e adicioná-lo à configuração do servidor.
$ xmake service --gen-token
New token a7b9fc2d3bfca1472aabc38bb5f5d612 is generated!
Autenticação de senha
Também fornecemos um modo de autorização de autenticação de senha. Comparado com a autenticação de token, ele exige que os usuários insiram uma senha toda vez que se conectarem e só podem ser conectados após a verificação ser aprovada.
Configuração de autenticação do servidor
Para autenticação de senha, não precisamos configurar manualmente o token, basta executar o seguinte comando para adicionar um usuário: Durante o processo de adição, o usuário será solicitado a digitar uma senha.
$ xmake service --add-user=ruki
Please input user ruki password:
123456
Add user ruki ok!
Em seguida, o xmake irá gerar um novo token através do nome de usuário e senha e adicioná-lo à lista de tokens configurada pelo servidor.
$ cat ~/.xmake/service/server.conf
{
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
remote_build = {
listen = "0.0.0.0:9691",
workdir = "/Users/ruki/.xmake/service/server/remote_build"
},
tokens = {
"e438d816c95958667747c318f1532c0f",
"7889e25402413e93fd37395a636bf942"
}
}
Claro, também podemos excluir o usuário e a senha especificados.
$xmake service --rm-user=ruki
Please input user ruki password:
123456
Remove user ruki ok!
Configuração de autenticação do cliente
Para o cliente, não precisamos mais definir o token do servidor. Precisamos apenas adicionar o nome do usuário que precisa estar conectado na configuração da conexão para habilitar a autenticação por senha. O formato é:user@address:port
$ cat ~/.xmake/service/client.conf
{
remote_build = {
connect = "[email protected]:9691"
}
}
!> Se o nome do usuário for removido e o token não estiver configurado, é modo anônimo.Se o servidor não estiver configurado com o token, a autenticação é completamente desabilitada e a conexão é feita diretamente.
Verificação de host confiável
Além disso, para melhorar ainda mais a segurança, também fornecemos verificação de host confiável do lado do servidor. Se o endereço IP do host cliente que pode ser conectado estiver configurado na lista known_hosts da configuração do servidor, somente esses hosts poderão se conectar com sucesso A conexão do servidor e de outros hosts a ele será solicitada como não confiável e recusará a conexão, mesmo que a autenticação do token e da senha esteja OK.
$ cat ~/.xmake/service/server.conf
{
logfile = "/Users/ruki/.xmake/service/logs.txt",
server = {
tokens = {
"4b928c7563a0cba10ff4c3f5ca0c8e24"
},
known_hosts = { "127.0.0.1", "xx.xx.xx.xx"}
}
}
conectar a um servidor remoto
Em seguida, precisamos apenas entrar no diretório raiz do projeto que precisa ser compilado remotamente, executar o comando e conectar. xmake service --connect
Se for o modo de autenticação de token, nenhuma entrada de senha adicional será necessária e a conexão será conectada diretamente.
$ xmake create test
$ cd test
$ xmake service --connect
<remote_build_client>: connect 192.168.56.110:9091 ..
<remote_build_client>: connected!
<remote_build_client>: sync files in 192.168.56.110:9091 ..
Scanning files ..
Comparing 3 files ..
[+]: src/main.cpp
[+]: .gitignore
[+]: xmake.lua
3 files has been changed!
Archiving files ..
Uploading files with 1372 bytes ..
<remote_build_client>: sync files ok!
Se for autenticação de senha, o usuário será solicitado a digitar a senha para continuar a conexão.
$ xmake service --connect
Please input user root password:
000000
<remote_build_client>: connect 127.0.0.1:9691 ..
<remote_build_client>: connected!
<remote_build_client>: sync files in 127.0.0.1:9691 ..
Scanning files ..
Comparing 3 files ..
[+]: xmake.lua
[+]: .gitignore
[+]: src/main.cpp
3 files has been changed!
Archiving files ..
Uploading files with 1591 bytes ..
<remote_build_client>: sync files ok!
Se a senha estiver incorreta, uma mensagem de erro será exibida.
$ xmake service --connect
Please input user root password:
123
<remote_build_client>: connect 127.0.0.1:9691 ..
<remote_build_client>: connect 127.0.0.1:9691 failed, user and password are incorrect!
Suporte de compilação distribuída
O Xmake fornece um serviço de compilação distribuído integrado, geralmente pode cooperar com o cache de compilação local e o cache de compilação remoto para obter a aceleração de compilação ideal.
Além disso, é totalmente compatível com várias plataformas, não apenas suportamos gcc/clang, mas também Windows e msvc.
Para a compilação cruzada, desde que o cross-toolchain suporte, não precisamos do ambiente do sistema do servidor. Mesmo que os recursos do servidor linux, macOS e Windows sejam misturados, a compilação distribuída pode ser bem realizada.
Iniciar o serviço
Podemos especificar um parâmetro para habilitar o serviço de compilação distribuída, claro, se este parâmetro não for especificado, o xmake habilitará todos os serviços configurados pelo servidor por padrão. --distcc
$ xmake service --distcc
<distcc_build_server>: listening 0.0.0.0:9093 ..
Também podemos iniciar o serviço e ecoar informações de log detalhadas.
$ xmake service --distcc -vD
<distcc_build_server>: listening 0.0.0.0:9093 ..
Inicie o serviço no modo Daemon
$ xmake service --distcc --start
$ xmake service --distcc --restart
$ xmake service --distcc --stop
Configurar o servidor
Primeiro, executamos o comando, ele gerará automaticamente um arquivo de configuração padrão, armazenado em . xmake service server.conf ~/.xmake/service/server.conf
$ xmake service
generating the config file to /Users/ruki/.xmake/service/server.conf ..
an token(590234653af52e91b9e438ed860f1a2b) is generated, we can use this token to connect service.
generating the config file to /Users/ruki/.xmake/service/client.conf ..
<distcc_build_server>: listening 0.0.0.0:9693 ..
Em seguida, editamos, corrigindo a porta de escuta do servidor (opcional).
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9693",
workdir = "/Users/ruki/.xmake/service/server/distcc_build"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Configurar o cliente
O arquivo de configuração do cliente está lá , podemos configurar o endereço do servidor ao qual o cliente precisa se conectar. ~/.xmake/service/client.conf
Podemos configurar vários endereços de servidor e tokens correspondentes na lista de hosts.
!> Compilação distribuída, recomenda-se usar o modo de autenticação de token, devido ao modo de senha, cada servidor precisa digitar a senha uma vez ao se conectar, o que é muito trabalhoso.
$cat ~/.xmake/service/client.conf
{
distcc_build = {
hosts = {
{
connect = "127.0.0.1:9693",
token = "590234653af52e91b9e438ed860f1a2b"
}
}
}
}
conectar ao servidor
Após configurar a autenticação e o endereço do servidor, você pode digitar o seguinte comando para conectar o projeto atual ao servidor configurado.
Precisamos inserir, ao conectar , para especificar que apenas o serviço distribuído está conectado. --distcc
$ cd projectdir
$ xmake service --connect --distcc
<client>: connect 127.0.0.1:9693 ..
<client>: 127.0.0.1:9693 connected!
Também podemos nos conectar a vários serviços ao mesmo tempo, como compilação distribuída e serviços de cache de compilação remota.
$ xmake service --connect --distcc --ccache
!> Se não houver parâmetro, a conexão padrão é o serviço de compilação remota.
Projeto de compilação distribuída
Após conectar ao servidor, podemos realizar a compilação distribuída como a compilação local normal, por exemplo:
$ xmake
...
[ 93%]: ccache compiling.release src/demo/network/unix_echo_client.c ----> local job
[ 93%]: ccache compiling.release src/demo/network/ipv6.c
[ 93%]: ccache compiling.release src/demo/network/ping.c
[ 93%]: distcc compiling.release src/demo/network/unix_echo_server.c. ----> distcc job
[ 93%]: distcc compiling.release src/demo/network/http.c
[ 93%]: distcc compiling.release src/demo/network/unixaddr.c
[ 93%]: distcc compiling.release src/demo/network/ipv4.c
[ 94%]: distcc compiling.release src/demo/network/ipaddr.c
[ 94%]: distcc compiling.release src/demo/math/fixed.c
[ 94%]: distcc compiling.release src/demo/libm/float.c
[ 95%]: ccache compiling.release src/demo/libm/double.c
[ 95%]: ccache compiling.release src/demo/other/test.cpp
[ 98%]: archiving.release libtbox.a
[ 99%]: linking.release demo
[100%]: build ok!
Entre elas, as palavras com distcc são tarefas de compilação remota e as outras são tarefas de compilação local.Por padrão, o xmake também habilita o cache de compilação local para armazenar em cache os resultados de compilação distribuídos para evitar solicitações freqüentes ao servidor.
Além disso, também podemos abrir o cache de compilação remoto e compartilhar o cache de compilação com outras pessoas para acelerar ainda mais a compilação do desenvolvimento colaborativo de várias pessoas.
desconectar
$ xmake service --disconnect --distcc
Especifique o número de tarefas de compilação paralela
Vamos apresentar brevemente o número de tarefas paralelas atualmente calculadas por padrão com base no número de núcleos de CPU do host:
local default_njob = math.ceil(ncpu * 3 / 2)
Portanto, se a compilação distribuída não estiver habilitada, o número máximo padrão de tarefas de compilação paralela é esse default_njob.
Se a compilação distribuída estiver habilitada, o número padrão de tarefas de compilação paralela é:
local maxjobs = default_njob + server_count * server_default_njob
Modifique o número de tarefas paralelas locais
Podemos especificar o número de tarefas paralelas locais apenas passando -o, mas isso não afetará o número de tarefas paralelas no lado do servidor. -jN
$ xmake -jN
Modifique o número de tarefas paralelas no servidor
Se você deseja modificar o número de tarefas paralelas no servidor, você precisa modificar o arquivo de configuração do cliente.
$cat ~/.xmake/service/client.conf
{
distcc_build = {
hosts = {
{
connect = "127.0.0.1:9693",
token = "590234653af52e91b9e438ed860f1a2b",
njob = 8 <------- modify here
},
{
connect = "192.168.01:9693",
token = "590234653af52e91b9e438ed860f1a2b",
njob = 4
}
}
}
}
Para cada host do servidor, adicione configuração de parâmetro para especificar o número de tarefas paralelas que esse servidor pode fornecer. njob = N
Compilação distribuída de projetos Android
O serviço de compilação distribuído fornecido pelo xmake é totalmente multiplataforma e suporta Windows, Linux, macOS, Android, iOS e até compilação cruzada.
Se você deseja compilar o projeto Android, basta adicionar a configuração do conjunto de ferramentas na configuração do servidor e fornecer o caminho do NDK. toolchains
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9693",
toolchains = {
ndk = {
ndk = "~/files/android-ndk-r21e" <------------ here
}
},
workdir = "/Users/ruki/.xmake/service/server/distcc_build"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Em seguida, podemos compilar o projeto Android de maneira distribuída, como a compilação local normal, e até configurar vários servidores Windows, macOS, Linux e outros hosts de servidor diferentes como recursos do serviço de compilação distribuído para compilá-lo.
Basta baixar o NDK da plataforma correspondente.
$ xmake f -p android --ndk=~/files/xxxx
$ xmake
Compilação distribuída de projetos iOS
Compilar projetos iOS é mais fácil, porque o Xmake geralmente pode detectar o Xcode automaticamente, então apenas mude a plataforma para ios como um local normal.
$ xmake f -p iphoneos
$ xmake
Configuração de compilação cruzada distribuída
Se quisermos distribuir a compilação cruzada, precisamos configurar o caminho do SDK da cadeia de ferramentas no lado do servidor, por exemplo:
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9693",
toolchains = {
cross = {
sdkdir = "~/files/arm-linux-xxx" <------------ here
}
},
workdir = "/Users/ruki/.xmake/service/server/distcc_build"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Entre eles, em toolchains, cada item corresponde a um toolchain, que aqui é configurado como cross toolchain . cross = {} toolchain("cross")
Na cadeia de ferramentas, podemos configurar , , etc., correspondentes ao , e outras configurações de interface dentro do . sdkdir bindir cross toolchain("cross") set_sdkdir set_bindir set_cross
Se a cadeia de ferramentas cruzada for mais padronizada, geralmente precisamos apenas configurar e o xmake pode detectá-la automaticamente. sdkdir
A compilação do lado do cliente só precisa especificar o diretório sdk.
$ xmake f -p cross --sdk=/xxx/arm-linux-xxx
$ xmake
limpar cache do servidor
A compilação de cada projeto no lado do servidor irá gerar alguns arquivos de cache, que são armazenados de acordo com a granularidade do projeto.Podemos usar o seguinte comando para limpar o cache correspondente a cada servidor para o projeto atual.
$ xmake service --clean --distcc
algumas otimizações internas
- Cache de resultados de compilação do lado do servidor para evitar compilações repetidas
- Cache local, otimização de cache remoto, evite comunicação desnecessária do servidor
- Agendamento de balanceamento de carga do servidor, alocação racional de recursos do servidor
- Arquivos pequenos são compilados diretamente localmente após o pré-processamento, o que geralmente é mais rápido
- Compressão em tempo real e transmissão de arquivos grandes, com base na compressão rápida lz4
- A manutenção do estado interno, em comparação com ferramentas independentes, como distcc, evita o carregamento frequente e o consumo de tempo do processo independente e evita a comunicação adicional com o processo daemon
Suporte a cache de compilação local
Por padrão, o Xmake habilitará o cache local.A versão anterior à 2.6.5 usa o ccache externo por padrão e, após a 2.6.6, o Xmake fornece uma solução de cache local multiplataforma integrada.
Comparado com processos independentes de terceiros, como ccache, a manutenção de estado interno do xmake é mais fácil de otimizar e também evita o carregamento e o consumo de tempo independente do processo e evita a comunicação adicional com o processo daemon.
Além disso, o cache interno pode suportar melhor a plataforma cruzada, e o msvc no Windows também pode suportar bem, enquanto o ccache suporta apenas gcc/clang.
Claro, também podemos desabilitar o cache com o seguinte comando.
$ xmake f --ccache=n
Nota: Independentemente de o cache local integrado ser usado ou não, o nome da configuração significa cache de compilação c/c++, não apenas o nome da ferramenta ccache. --ccache=
Se quisermos continuar usando outras ferramentas externas de cache, também podemos configurá-lo da seguinte maneira.
$ xmake f --ccache=n --cxx="ccache gcc" --cc="ccache gcc"
$ xmake
Suporte a cache de compilação remota
Além do cache local, também fornecemos um serviço de cache remoto, semelhante ao sscache da mozilla, se for apenas para desenvolvimento pessoal, geralmente não é usado.
No entanto, se um projeto de grande escala for desenvolvido de forma colaborativa por várias pessoas dentro da empresa, apenas a compilação distribuída e o armazenamento em cache local não são suficientes. Também precisamos armazenar em cache os arquivos de objeto compilados em um servidor separado para compartilhamento.
Dessa forma, mesmo que outras pessoas o compilem pela primeira vez, eles não precisam compilá-lo de forma distribuída todas as vezes e puxar o cache diretamente do controle remoto para acelerar a compilação.
Além disso, o serviço de cache remoto fornecido pelo Xmake também é suportado por todas as plataformas, não apenas gcc/clang, mas também msvc.
Iniciar o serviço
Podemos especificar um parâmetro para habilitar o serviço de cache de compilação remota.Claro, se este parâmetro não for especificado, o xmake habilitará todos os serviços configurados pelo servidor por padrão. --ccache
$ xmake service --ccache
<remote_cache_server>: listening 0.0.0.0:9092 ..
Também podemos iniciar o serviço e ecoar informações de log detalhadas.
$ xmake service --ccache -vD
<remote_cache_server>: listening 0.0.0.0:9092 ..
Inicie o serviço no modo Daemon
$ xmake service --ccache --start
$ xmake service --ccache --restart
$ xmake service --ccache --stop
Configurar o servidor
Primeiro, executamos o comando, ele gerará automaticamente um arquivo de configuração padrão, armazenado em . xmake service server.conf ~/.xmake/service/server.conf
$ xmake service
generating the config file to /Users/ruki/.xmake/service/server.conf ..
an token(590234653af52e91b9e438ed860f1a2b) is generated, we can use this token to connect service.
generating the config file to /Users/ruki/.xmake/service/client.conf ..
<remote_cache_server>: listening 0.0.0.0:9692 ..
Em seguida, editamos, corrigindo a porta de escuta do servidor (opcional).
$ cat ~/.xmake/service/server.conf
{
distcc_build = {
listen = "0.0.0.0:9692",
workdir = "/Users/ruki/.xmake/service/server/remote_cache"
},
known_hosts = { },
logfile = "/Users/ruki/.xmake/service/server/logs.txt",
tokens = {
"590234653af52e91b9e438ed860f1a2b"
}
}
Configurar o cliente
O arquivo de configuração do cliente está lá , podemos configurar o endereço do servidor ao qual o cliente precisa se conectar. ~/.xmake/service/client.conf
Podemos configurar vários endereços de servidor e tokens correspondentes na lista de hosts.
$cat ~/.xmake/service/client.conf
{
remote_cache = {
connect = "127.0.0.1:9692,
token = "590234653af52e91b9e438ed860f1a2b"
}
}
}
conectar ao servidor
Após configurar a autenticação e o endereço do servidor, você pode digitar o seguinte comando para conectar o projeto atual ao servidor configurado.
Ao conectar, precisamos inserir e especificar que apenas o serviço de cache de compilação remota está conectado. --ccache
$ cd projectdir
$ xmake service --connect --ccache
<client>: connect 127.0.0.1:9692 ..
<client>: 127.0.0.1:9692 connected!
Também podemos nos conectar a vários serviços ao mesmo tempo, como compilação distribuída e serviços de cache de compilação remota.
$ xmake service --connect --distcc --ccache
!> Se não houver parâmetro, a conexão padrão é o serviço de compilação remota.
desconectar
$ xmake service --disconnect --ccache
limpar cache do servidor
Também podemos usar o seguinte comando para limpar o cache no servidor remoto correspondente ao projeto atual.
$ xmake service --clean --ccache
E se o executarmos , no estado de conexão com o serviço remoto, ele também limpará automaticamente todos os caches. xmake clean --all
algumas otimizações internas
- Extraia o instantâneo do cache remoto e envie-o de volta ao local por meio do filtro bloom + lz4, que é usado para determinar rapidamente se o cache existe e evitar consultar frequentemente as informações do cache do servidor
- Com o cache local, você pode evitar solicitações frequentes ao servidor remoto e fazer pull do cache.
- A manutenção do estado interno, em comparação com ferramentas independentes, como sscache, evita o carregamento frequente de processos independentes e demorado, e evita comunicação adicional com daemons
Suporte de Engenharia Keil/C51
Só precisamos vincular à cadeia de ferramentas c51, o Xmake pode detectar automaticamente o ambiente da cadeia de ferramentas Keil/C51 SDK instalado no sistema e usá-lo para compilar.
target("hello")
add_rules("c51.binary")
set_toolchains("c51")
add_files("src/main.c")
Claro, se não definirmos a cadeia de ferramentas, também podemos alternar para a cadeia de ferramentas c51 manualmente. set_toolchains("c51") xmake f --toolchain=c51
atualizar conteúdo
Novas características
- #2327 : Suporte ao compilador nvc/nvc++/nvfortran na cadeia de ferramentas nvidia-hpc-sdk
- Adicionar interface de instância de caminho
- #2334 : Adicionar módulo de compressão lz4
- #2349 : Adicionar suporte ao projeto keil/c51
- #274 : Suporte a compilação distribuída entre plataformas
- Use o cache local integrado em vez do ccache
Melhorar
- #2309 : Compilação remota suporta verificação de autorização do usuário
- Melhore a compilação remota, adicione suporte para compactação lz4
Correções de bugs
- Corrige a falha causada pela pilha lua desbalanceada ao selecionar a versão do pacote