Como faço para que o Windows vá tão rápido quanto o Linux para compilar C ++?

Eu sei que isso não é tanto uma questão de programação, mas é relevante.

Trabalho em um projeto de plataforma cruzada bastante grande . No Windows, uso o VC ++ 2008. No Linux, uso o gcc. Existem cerca de 40k arquivos no projeto. O Windows é 10x a 40x mais lento que o Linux na compilação e vinculação do mesmo projeto. Como posso consertar isso?

Uma construção incremental de uma única alteração 20 segundos no Linux e> 3 minutos no Windows. Por quê? Posso até instalar o vinculador 'gold' no Linux e reduzir esse tempo para 7 segundos.

Da mesma forma, o git é 10 a 40 vezes mais rápido no Linux que no Windows.

No caso do git, é possível que o git não esteja usando o Windows da maneira ideal, mas o VC ++? Você acha que a Microsoft gostaria de tornar seus próprios desenvolvedores o mais produtivos possível e uma compilação mais rápida ajudaria bastante nisso. Talvez eles estejam tentando incentivar os desenvolvedores a usar C #?

Como teste simples, encontre uma pasta com muitas subpastas e faça um simples

dir /s > c:\list.txt

no Windows. Faça isso duas vezes e cronometre a segunda execução para que seja executada no cache. Copie os arquivos para o Linux e faça 2 execuções equivalentes e cronometre a segunda execução.

ls -R > /tmp/list.txt

Eu tenho 2 estações de trabalho com exatamente as mesmas especificações. HP Z600s com 12gig de ram, 8 núcleos a 3,0ghz. Em uma pasta com ~ 400k arquivos, o Windows leva 40 segundos, o Linux leva <1 segundo.

Existe uma configuração de registro que eu possa definir para acelerar o Windows? O que da?

Alguns links levemente relevantes, relevantes para os tempos de compilação, não necessariamente de E / S.

• Aparentemente, há um problema no Windows 10 (não no Windows 7) que fechar um processo mantém um bloqueio global . Ao compilar com vários núcleos e, portanto, com vários processos, esse problema ocorre.

• A /analyseopção pode afetar adversamente o perf porque carrega um navegador da web . (Não é relevante aqui, mas é bom saber)

A menos que um hacker de sistemas Windows hardcore apareça, você não receberá mais do que comentários partidários (o que não farei) e especulações (que é o que vou tentar).

1. Sistema de arquivos - Você deve tentar as mesmas operações (incluindo a dir) no mesmo sistema de arquivos. Me deparei com isso que avalia alguns sistemas de arquivos para vários parâmetros.

2. Armazenamento em cache. Uma vez, tentei executar uma compilação no Linux em um disco RAM e descobri que era mais lento do que executá-lo em disco, graças à maneira como o kernel cuida do cache. Este é um ponto de venda sólido para Linux e pode ser a razão pela qual o desempenho é tão diferente.

3. Especificações de dependência incorretas no Windows. Talvez as especificações de dependência de cromo para o Windows não sejam tão corretas quanto para o Linux. Isso pode resultar em compilações desnecessárias quando você faz uma pequena alteração. Você pode validar isso usando a mesma cadeia de ferramentas do compilador no Windows.

Algumas idéias:

1. Desative os nomes 8.3. Isso pode ser um grande fator em unidades com um grande número de arquivos e um número relativamente pequeno de pastas:fsutil behavior set disable8dot3 1
2. Use mais pastas. Na minha experiência, o NTFS começa a desacelerar com mais de 1000 arquivos por pasta.
3. Habilitar compilações paralelas com o MSBuild; basta adicionar a opção "/ m" e ela iniciará automaticamente uma cópia do MSBuild por núcleo de CPU.
4. Coloque seus arquivos em um SSD - ajuda imensamente para E / S aleatória.
5. Se o tamanho médio do arquivo for muito maior que 4 KB, considere reconstruir o sistema de arquivos com um tamanho de cluster maior que corresponda aproximadamente ao tamanho médio do arquivo.
6. Verifique se os arquivos foram desfragmentados. Arquivos fragmentados causam muitas buscas em disco, o que pode custar um fator de mais de 40 na taxa de transferência. Use o utilitário "contig" da sysinternals ou o desfragmentador interno do Windows.
7. Se o tamanho médio do arquivo for pequeno e a partição em que estiver relativamente cheia, é possível que você esteja executando uma MFT fragmentada, prejudicando o desempenho. Além disso, arquivos menores que 1K são armazenados diretamente na MFT. O utilitário "contig" mencionado acima pode ajudar, ou pode ser necessário aumentar o tamanho da MFT. O comando a seguir duplicará, para 25% do volume: fsutil behavior set mftzone 2Altere o último número para 3 ou 4 para aumentar o tamanho em incrementos adicionais de 12,5%. Após executar o comando, reinicie e crie o sistema de arquivos.
8. Desativar o último horário de acesso: fsutil behavior set disablelastaccess 1
9. Desabilitar o serviço de indexação
10. Desative seu software antivírus e anti-spyware ou, pelo menos, defina as pastas relevantes para serem ignoradas.
11. Coloque seus arquivos em uma unidade física diferente do sistema operacional e do arquivo de paginação. O uso de uma unidade física separada permite que o Windows use E / Ss paralelas para ambas as unidades.
12. Dê uma olhada nos seus sinalizadores de compilador. O compilador do Windows C ++ tem várias opções; verifique se você está usando apenas os que realmente precisa.
13. Tente aumentar a quantidade de memória que o sistema operacional usa para buffers de pool paginado (verifique se você tem RAM suficiente primeiro): fsutil behavior set memoryusage 2
14. Verifique o log de erros do Windows para verificar se você não está enfrentando erros ocasionais no disco.
15. Dê uma olhada nos contadores de desempenho relacionados ao disco físico para ver como seus discos estão ocupados. Longos comprimentos de fila ou longos períodos de transferência são maus sinais.
16. Os primeiros 30% das partições de disco são muito mais rápidos que o restante do disco em termos de tempo de transferência bruto. Partições mais estreitas também ajudam a minimizar os tempos de busca.
17. Você está usando RAID? Nesse caso, pode ser necessário otimizar sua escolha do tipo RAID (o RAID-5 é ruim para operações de gravação pesada, como compilação)
18. Desative todos os serviços que você não precisa
19. Desfragmentar pastas: copie todos os arquivos para outra unidade (apenas os arquivos), exclua os arquivos originais, copie todas as pastas para outra unidade (apenas as pastas vazias), exclua as pastas originais, desfragmente a unidade original, copie a estrutura de pastas novamente e copie os arquivos. Quando o Windows cria pastas grandes, um arquivo por vez, as pastas acabam sendo fragmentadas e lentas. ("contig" também deve ajudar aqui)
20. Se você estiver ligado à E / S e tiver ciclos de CPU de sobra, tente ativar a compactação de disco. Pode fornecer algumas acelerações significativas para arquivos altamente compactáveis ​​(como código fonte), com algum custo na CPU.

O NTFS economiza tempo de acesso ao arquivo sempre. Você pode tentar desativá-lo: "conjunto de comportamentos fsutil disablelastaccess 1" (reiniciar)

O problema com o visual c ++ é, até onde posso dizer, que não é uma prioridade para a equipe do compilador otimizar esse cenário. A solução deles é que você use o recurso de cabeçalho pré-compilado. Isso é o que os projetos específicos do Windows fizeram. Não é portátil, mas funciona.

Além disso, no Windows, você normalmente possui scanners de vírus, além de ferramentas de restauração e pesquisa do sistema que podem arruinar completamente o tempo de construção, se monitorar a sua pasta buid. O monitor de recursos do Windows 7 pode ajudá-lo a identificá-lo. Eu tenho uma resposta aqui com mais algumas dicas para otimizar os tempos de compilação do vc ++, se você estiver realmente interessado.

Pessoalmente, descobri que rodar uma máquina virtual Windows no linux conseguiu remover grande parte da lentidão de IO no Windows, provavelmente porque o linux vm fazia muito cache do que o próprio Windows não estava.

Ao fazer isso, fui capaz de acelerar os tempos de compilação de um grande projeto C ++ (250Kloc) no qual estava trabalhando, de 15 minutos a 6 minutos.

A dificuldade de fazer isso se deve ao fato de o C ++ tender a se espalhar e ao processo de compilação por muitos arquivos pequenos e individuais. Isso é algo em que o Linux é bom e o Windows não. Se você deseja criar um compilador C ++ realmente rápido para Windows, tente manter tudo na RAM e toque no sistema de arquivos o mínimo possível.

Também é assim que você cria uma cadeia de compilação do Linux C ++ mais rápida, mas é menos importante no Linux porque o sistema de arquivos já está fazendo muito desse ajuste para você.

A razão para isso é devido à cultura Unix: Historicamente, o desempenho do sistema de arquivos tem sido uma prioridade muito maior no mundo Unix do que no Windows. Para não dizer que não foi uma prioridade no Windows, apenas no Unix foi uma prioridade mais alta.

1. Acesso ao código fonte.

   Você não pode mudar o que não pode controlar. A falta de acesso ao código-fonte do Windows NTFS significa que a maioria dos esforços para melhorar o desempenho ocorreu apesar de melhorias no hardware. Ou seja, se o desempenho for lento, você solucionará o problema melhorando o hardware: o barramento, a mídia de armazenamento e assim por diante. Você só pode fazer muito se precisar solucionar o problema, não corrigi-lo.

   O acesso ao código fonte do Unix (mesmo antes do código aberto) foi mais amplo. Portanto, se você quiser melhorar o desempenho, dirija-o primeiro ao software (mais barato e fácil) e ao hardware em segundo.

   Como resultado, há muitas pessoas no mundo que obtiveram seus PhDs estudando o sistema de arquivos Unix e encontrando novas maneiras de melhorar o desempenho.

2. O Unix tende a muitos arquivos pequenos; O Windows tende a poucos (ou um) arquivo grande.

   Aplicativos Unix tendem a lidar com muitos arquivos pequenos. Pense em um ambiente de desenvolvimento de software: muitos arquivos de origem pequenos, cada um com seu próprio objetivo. O estágio final (vinculação) cria um arquivo grande, mas essa é uma pequena porcentagem.

   Como resultado, o Unix otimizou as chamadas do sistema para abrir e fechar arquivos, verificar diretórios e assim por diante. A história dos trabalhos de pesquisa do Unix abrange décadas de otimizações do sistema de arquivos que refletem muito na melhoria do acesso ao diretório (pesquisas e verificações de diretório completo), abertura inicial de arquivos e assim por diante.

   Os aplicativos do Windows tendem a abrir um arquivo grande, mantê-lo aberto por um longo tempo e fechá-lo quando terminar. Pense no MS-Word. O msword.exe (ou o que for) abre o arquivo uma vez e é anexado por horas, atualiza blocos internos e assim por diante. O valor de otimizar a abertura do arquivo seria perda de tempo.

   O histórico de benchmarking e otimização do Windows tem sido a rapidez com que se pode ler ou gravar arquivos longos. Isso é o que é otimizado.

   Infelizmente, o desenvolvimento de software tem tendência para a primeira situação. Heck, o melhor sistema de processamento de texto para Unix (TeX / LaTeX) incentiva você a colocar cada capítulo em um arquivo diferente e #incluir todos eles juntos.

3. Unix é focado em alto desempenho; O Windows está focado na experiência do usuário

   O Unix foi iniciado na sala do servidor: sem interface com o usuário. A única coisa que os usuários veem é a velocidade. Portanto, a velocidade é uma prioridade.

   O Windows iniciou na área de trabalho: os usuários se preocupam apenas com o que veem e com a interface do usuário. Portanto, mais energia é gasta na melhoria da interface do usuário do que no desempenho.

4. O ecossistema do Windows depende da obsolescência planejada. Por que otimizar o software quando o novo hardware está a apenas um ou dois anos?

   Não acredito em teorias da conspiração, mas, se acreditasse, apontaria que na cultura Windows há menos incentivos para melhorar o desempenho. Os modelos de negócios do Windows dependem de pessoas que compram novas máquinas, como um relógio. (É por isso que o preço das ações de milhares de empresas é afetado se a MS enviar um sistema operacional com atraso ou se a Intel perder a data de lançamento do chip.). Isso significa que há um incentivo para resolver problemas de desempenho, dizendo às pessoas para comprarem novo hardware; não melhorando o problema real: sistemas operacionais lentos. O Unix vem da academia, onde o orçamento é pequeno e você pode obter seu doutorado inventando uma nova maneira de tornar os sistemas de arquivos mais rápidos; raramente alguém na academia obtém pontos por resolver um problema emitindo um pedido de compra.

   Além disso, como o Unix é de código aberto (mesmo quando não era, todos tinham acesso à fonte), qualquer estudante de doutorado entediado pode ler o código e se tornar famoso ao torná-lo melhor. Isso não acontece no Windows (a MS possui um programa que dá acesso aos acadêmicos ao código-fonte do Windows, raramente é aproveitado). Veja esta seleção de artigos sobre desempenho relacionados ao Unix: http://www.eecs.harvard.edu/margo/papers/ ou consulte a história dos artigos de Osterhaus, Henry Spencer ou outros. Heck, um dos maiores (e mais agradáveis ​​de assistir) debates na história do Unix foi entre Osterhaus e Selzer http://www.eecs.harvard.edu/margo/papers/usenix95-lfs/supplement/rebuttal. html Você não vê esse tipo de coisa acontecendo no mundo do Windows. Você pode ver os fornecedores se destacando, mas isso parece ser muito mais raro ultimamente, já que a inovação parece estar no nível do corpo dos padrões.

É assim que eu vejo.

Atualização: se você observar as novas cadeias de compiladores que estão saindo da Microsoft, ficará muito otimista porque muito do que elas estão fazendo facilita a manutenção de toda a cadeia de ferramentas na RAM e a repetição de menos trabalho. Coisas muito impressionantes.

Ligação incremental

Se a solução VC 2008 estiver configurada como vários projetos com saídas .lib, você precisará definir "Usar entradas de dependência da biblioteca"; isso faz o vinculador vincular diretamente aos arquivos .obj, em vez dos arquivos .lib. (E, na verdade, torna o link incrementalmente.)

Desempenho de travessia de diretório

É um pouco injusto comparar o rastreamento de diretório na máquina original com o rastreamento de um diretório recém-criado com os mesmos arquivos em outra máquina. Se você deseja um teste equivalente, provavelmente deve fazer outra cópia do diretório na máquina de origem. (Ainda pode ser lento, mas isso pode ser devido a várias coisas: fragmentação do disco, nomes curtos de arquivos, serviços em segundo plano etc.) Embora eu ache que os problemas de perf dir /stêm mais a ver com escrever a saída do que medir o arquivo real desempenho transversal. Even dir /s /b > nulé lento na minha máquina com um diretório enorme.

Tenho certeza de que está relacionado ao sistema de arquivos. Trabalho em um projeto de plataforma cruzada para Linux e Windows, onde todo o código é comum, exceto onde o código dependente da plataforma é absolutamente necessário. Usamos Mercurial, não git, portanto o "Linuxness" do git não se aplica. A inserção de alterações no repositório central leva uma eternidade no Windows em comparação ao Linux, mas devo dizer que nossas máquinas com Windows 7 se saem muito melhor do que as do Windows XP. Compilar o código depois disso é ainda pior no VS 2008. Não é apenas hg; O CMake também é muito mais lento no Windows, e essas duas ferramentas usam o sistema de arquivos mais do que qualquer outra coisa.

O problema é tão grave que a maioria dos nossos desenvolvedores que trabalham em um ambiente Windows nem se incomodam mais em criar construções incrementais - eles acham que fazer uma construção de unidade é mais rápido.

Aliás, se você quiser diminuir drasticamente a velocidade de compilação no Windows, sugiro a compilação de unidade mencionada acima. É difícil implementar corretamente no sistema de compilação (eu fiz isso para nossa equipe no CMake), mas, uma vez feito, acelera automaticamente as coisas para nossos servidores de integração contínua. Dependendo de quantos binários seu sistema de compilação está distribuindo, você pode obter uma ou duas ordens de melhoria de magnitude. Sua milhagem pode variar. No nosso caso, acho que acelerou o Linux três vezes e o Windows um fator 10, mas temos muitas bibliotecas e executáveis ​​compartilhados (o que diminui as vantagens de uma unidade).

Como você constrói seu grande projeto de plataforma cruzada? Se você estiver usando makefiles comuns para Linux e Windows, poderá degradar facilmente o desempenho do Windows por um fator de 10 se os makefiles não forem projetados para serem rápidos no Windows.

Eu apenas corrigi alguns makefiles de um projeto de plataforma cruzada usando makefiles comuns (GNU) para Linux e Windows. Make está iniciando um sh.exeprocesso para cada linha de uma receita causando a diferença de desempenho entre Windows e Linux!

De acordo com o GNU make document

.ONESHELL:

deve resolver o problema, mas esse recurso (atualmente) não é suportado pelo Windows make. Portanto, reescrever as receitas em linhas lógicas únicas (por exemplo, adicionando; \ ou \ no final das linhas atuais do editor) funcionou muito bem!

IMHO, isso é tudo sobre desempenho de E / S de disco. A ordem de magnitude sugere que muitas operações vão para o disco no Windows, enquanto são tratadas na memória no Linux, ou seja, o Linux está melhor em cache. Sua melhor opção no Windows será mover seus arquivos para um disco, servidor ou sistema de arquivos rápido. Considere comprar uma unidade de estado sólido ou mover seus arquivos para um servidor NFS ramdisk ou rápido.

Eu executei os testes de passagem de diretório e os resultados estão muito próximos dos tempos de compilação relatados, sugerindo que isso não tem nada a ver com os tempos de processamento da CPU ou com os algoritmos do compilador / vinculador.

Tempos medidos, conforme sugerido acima, atravessando a árvore de diretórios do chromium:

• Windows Home Premium 7 (8 GB de RAM) em NTFS: 32 segundos
• Ubuntu 11.04 Linux (2GB de RAM) em NTFS: 10 segundos
• Ubuntu 11.04 Linux (2GB de RAM) no ext4: 0.6 segundos

Para os testes, puxei as fontes de cromo (ambas sob win / linux)

git clone http://github.com/chromium/chromium.git 
cd chromium
git checkout remotes/origin/trunk 

Para medir o tempo que corri

ls -lR > ../list.txt ; time ls -lR > ../list.txt # bash
dir -Recurse > ../list.txt ; (measure-command { dir -Recurse > ../list.txt }).TotalSeconds  #Powershell

Desativei os carimbos de data e hora de acesso, meu antivírus e aumentei as configurações do gerenciador de cache no Windows (> 2 GB de RAM) - tudo sem melhorias visíveis. O fato é que, fora da caixa, o Linux teve um desempenho 50x melhor que o Windows, com um quarto da RAM.

Para quem quiser argumentar que os números estão errados - por qualquer motivo - tente e publique suas descobertas.

Tente usar jom em vez de nmake

Obtenha aqui: https://github.com/qt-labs/jom

O fato é que o nmake está usando apenas um de seus núcleos, jom é um clone do nmake que faz uso de processadores multicore.

O GNU faz isso imediatamente, graças à opção -j, que pode ser a razão de sua velocidade em relação ao Microsoft nmake.

O jom trabalha executando paralelamente comandos make diferentes em diferentes processadores / núcleos. Experimente a diferença!

Quero adicionar apenas uma observação usando o Gnu make e outras ferramentas das ferramentas MinGW no Windows: elas parecem resolver nomes de host mesmo quando as ferramentas nem conseguem se comunicar via IP. Eu acho que isso é causado por alguma rotina de inicialização do tempo de execução do MinGW. A execução de um proxy DNS local me ajudou a melhorar a velocidade de compilação com essas ferramentas.

Antes, tive uma grande dor de cabeça porque a velocidade de compilação caiu um fator de 10 ou mais quando abri uma conexão VPN em paralelo. Nesse caso, todas essas pesquisas de DNS passaram pela VPN.

Essa observação também pode se aplicar a outras ferramentas de construção, não apenas baseadas no MinGW, mas também pode ter sido alterada na versão mais recente do MinGW.

Recentemente, pude arquivar outra maneira de acelerar a compilação em cerca de 10% no Windows usando o Gnu make, substituindo o mingw bash.exe pela versão do win-bash

(O win-bash não é muito confortável com relação à edição interativa.)