Parece haver alguma controvérsia sobre se o número de trabalhos no GNU make é suposto ser igual ao número de núcleos, ou se você pode otimizar o tempo de construção adicionando um trabalho extra que pode ser colocado na fila enquanto os outros "trabalham" .
É melhor usar -j4
ou -j5
em um sistema quad core?
Você viu (ou fez) algum benchmarking que apóia um ou outro?
make `nproc`
para fazer um script independente da CPU :)Respostas:
Eu diria que a melhor coisa a fazer é comparar você mesmo com seu ambiente e carga de trabalho específicos. Parece que existem muitas variáveis (tamanho / número de arquivos de origem, memória disponível, cache de disco, se o diretório de origem e os cabeçalhos do sistema estão localizados em discos diferentes, etc.) para uma resposta única.
Minha experiência pessoal (em um MacBook Pro de 2 núcleos) é que -j2 é significativamente mais rápido que -j1, mas além disso (-j3, -j4 etc.) não há aumento de velocidade mensurável. Portanto, para o meu ambiente, "jobs == number of core" parece ser uma boa resposta. (YMMV)
fonte
Executei meu projeto doméstico no meu laptop de 4 núcleos com hyperthreading e registrei os resultados. Este é um projeto bastante pesado do compilador, mas inclui um teste de unidade de 17,7 segundos no final. As compilações não são muito intensivas em IO; há muita memória disponível e se não, o resto está em um SSD rápido.
Resultados básicos:
Meu palpite agora: se você fizer outra coisa no seu computador, use a contagem de núcleos. Caso contrário, use a contagem de threads. Exceder isso não mostra nenhum benefício. Em algum ponto, eles ficarão com a memória limitada e entrarão em colapso devido a isso, tornando a compilação muito mais lenta. A linha "inf" foi adicionada em uma data muito posterior, dando-me a suspeita de que havia algum afogamento térmico para os trabalhos 8+. Isso mostra que para esse tamanho de projeto não há memória ou limite de rendimento em vigor. É um projeto pequeno, porém, com 8 GB de memória para compilar.
fonte
Eu, pessoalmente, uso
make -j n
onde n é "número de núcleos" + 1.Não posso, no entanto, dar uma explicação científica: tenho visto muitas pessoas usando as mesmas configurações e me deram resultados muito bons até agora.
De qualquer forma, você tem que ter cuidado porque alguns make-chains simplesmente não são compatíveis com a
--jobs
opção e podem levar a resultados inesperados. Se você estiver enfrentando erros de dependência estranhos, tentemake
sem--jobs
.fonte
No final das contas, você terá que fazer alguns benchmarks para determinar o melhor número a ser usado para sua construção, mas lembre-se de que a CPU não é o único recurso que importa!
Se você tem uma construção que depende muito do disco, por exemplo, a geração de muitos trabalhos em um sistema multicore pode ser mais lenta , pois o disco terá que fazer um trabalho extra movendo a cabeça do disco para frente e para trás para atender a todos os diferentes trabalhos (dependendo de muitos fatores, como o quão bem o sistema operacional lida com o cache de disco, suporte de enfileiramento de comando nativo pelo disco, etc.).
E então você tem núcleos "reais" versus hyper-threading. Você pode ou não se beneficiar da geração de jobs para cada hyper-thread. Novamente, você terá que fazer um benchmark para descobrir.
Não posso dizer que tentei especificamente #cores + 1 , mas em nossos sistemas (Intel i7 940, 4 núcleos hyperthreaded, muita RAM e drives VelociRaptor) e nosso build (build C ++ em grande escala que alterna CPU e I / O) há muito pouca diferença entre -j4 e -j8. (É talvez 15% melhor ... mas nem de longe duas vezes melhor.)
Se vou almoçar fora, usarei -j8, mas se quiser usar meu sistema para qualquer outra coisa durante a construção, usarei um número menor. :)
fonte
-j 8
Acabei de comprar um proc Athlon II X2 Regor com um Foxconn M / B e 4 GB de memória G-Skill.
Coloquei meu 'cat / proc / cpuinfo' e 'free' no final deste para que outras pessoas possam ver minhas especificações. É um Athlon II x2 dual core com 4 GB de RAM.
Eu baixei a próxima etapa do código-fonte do kernel (linux-3.2.46) para / archive4;
extraiu (
tar -xjvf linux-3.2.46.tar.bz2
);cd'd no diretório (
cd linux-3.2.46
);e copiou a configuração do kernel padrão em (
cp /usr/src/linux/.config .
);usado
make oldconfig
para preparar a configuração do kernel 3.2.46;então executou make com vários encantamentos de -jX.
Testei os tempos de cada execução emitindo make após o comando time, por exemplo, 'time make -j2'. Entre cada execução, 'rm -rf' a árvore linux-3.2.46 e a extrai novamente, copiei o /usr/src/linux/.config padrão para o diretório, executei make oldconfig e então fiz meu teste 'make -jX' novamente .
"make" simples:
como acima, mas com make -j2
como acima, mas com make -j3
como acima, mas com make -j4
como acima, mas com make -j8
'cat / proc / cpuinfo' produz:
'grátis' rende:
fonte
make -j
faz nesse sistema? O make deve verificar a carga e dimensionar o número de processos com base na carga.make -j
não limita o número de empregos. Isso geralmente é desastroso em um projeto de médio ou grande porte, pois mais tarefas são bifurcadas do que pode ser suportado pela RAM. A opção que você precisa restringir por carga é-l [load]
, em conjunto com-j
Ambos não estão errados. Para ficar em paz consigo mesmo e com o autor do software que você está compilando (diferentes restrições multi-thread / single-thread se aplicam ao próprio nível de software), sugiro que você use:
Notas:
nproc
é um comando do linux que retornará o número de núcleos / threads (CPU moderna) disponíveis no sistema. Colocá-lo sob marcas `como acima irá passar o número para o comando make.Informações adicionais: como alguém mencionou, usar todos os núcleos / threads para compilar software pode literalmente sufocar sua caixa até a morte (não responder) e pode até demorar mais do que usar menos núcleos. Como vi um usuário do Slackware aqui postado, ele tinha CPU dual core, mas ainda fornecia testes até j 8, que parou de ser diferente em j 2 (apenas 2 núcleos de hardware que a CPU pode utilizar). Portanto, para evitar que a caixa não responda, sugiro que você a execute assim:
Isso vai passar a saída
nproc
paramake
e subtrair 2 núcleos de seu resultado.fonte
Apenas como referência:
Da
Spawning Multiple Build Jobs
seção em LKD :fonte
Pela minha experiência, deve haver alguns benefícios de desempenho ao adicionar trabalhos extras. É simplesmente porque a E / S de disco é um dos gargalos além da CPU. No entanto, não é fácil decidir sobre o número de trabalhos extras, pois está altamente interconectado com o número de núcleos e tipos de disco sendo usados.
fonte
Muitos anos depois, a maioria dessas respostas ainda está correta. No entanto, houve uma pequena mudança: usar mais jobs do que núcleos físicos agora oferece uma aceleração genuinamente significativa. Como um adendo à tabela de Dascandy, aqui está meu tempo para compilar um projeto em um AMD Ryzen 5 3600X no Linux. (The Powder Toy, commit c6f653ac3cef03acfbc44e8f29f11e1b301f1ca2)
Eu recomendo verificar você mesmo, mas descobri com a entrada de outras pessoas que usar sua contagem de núcleo lógico para contagem de empregos funciona bem no Zen. Paralelamente, o sistema não parece perder a capacidade de resposta. Imagino que isso também se aplique a CPUs Intel recentes. Observe que eu também tenho um SSD, então pode valer a pena testar sua CPU você mesmo.
Testes feitos no Ubuntu 19,10 com Ryzen 5 3600X, Samsung 860 Evo SSD (SATA) e 32 GB de RAM
Nota final: outras pessoas com 3600X podem obter tempos melhores do que eu. Ao fazer este teste, habilitei o modo Eco, reduzindo um pouco a velocidade do processador.
fonte
SIM! No meu 3950x, eu executo -j32 e economiza horas de tempo de compilação! Eu ainda posso assistir o youtube, navegar na web, etc. durante a compilação sem qualquer diferença. O processador nem sempre é compatível, mesmo com um nvme de 1 TB 970 PRO ou Auros Gen4 de 1 TB e 64 GB de 3200C14. Mesmo quando é, não percebo a interface do usuário. Planejo testar com -j48 em um futuro próximo em alguns grandes projetos futuros. Espero, como você provavelmente, ver alguma melhora impressionante. Aqueles ainda com um quad-core podem não obter os mesmos ganhos ....
O próprio Linus acabou de atualizar para um 3970x e você pode apostar seu último dólar, ele está executando pelo menos -j64.
fonte