Estou em um MacBook Pro de segunda mão do final de 2013 (Mojave 10.14.3) e quando digito archno Terminal, recebo de volta i386. Não deveria ser um x86_64? O vendedor deturpou o item? Veja a captura de tela abaixo de 'Sobre este Mac' .
Minha suposição básica é que, quando os únicos fatores limitantes de um processo são disco e CPU, o "iowait" total do sistema + uso da CPU deve ser igual a pelo menos 100% de uma CPU lógica. (Em outros casos, isso não acontecerá. Por exemplo, ao baixar um arquivo usando wget, a rede geralmente é o fator limitante).
Esta suposição é violada por um teste simples. Isso é esperado? Se for esperado, existe um conjunto de condições em que devo esperar que minha suposição seja verdadeira?
Há alguns antecedentes sobre "iowait" aqui: Como uma CPU sabe que há IO pendente? A resposta aqui cita a ideia contra-intuitiva de que a espera cumulativa "pode diminuir em certas condições". Gostaria de saber se meu teste simples pode estar desencadeando uma condição tão não documentada?
ATUALIZAÇÃO : Por favor , pule para a resposta .
A resposta tem um teste mais simples do que o que usei originalmente. Eu preservei a pergunta original abaixo. A pergunta original pode mostrar alguns detalhes adicionais.
Pergunta original
Em um pequeno teste, costumo ddsolicitar ao kernel para gerar bytes aleatórios e gravá-los em um arquivo. Eu executo o ddcomando dentro perf statde , apenas para obter uma contagem do tempo de CPU gasto dentro do kernel. Eu também corro dentro perf trace -s, para relatar o tempo gasto dentro write(). Ao mesmo tempo, corro vmstat 5em outro terminal, para ver o sistema "iowait".
- Eu esperava ver pelo menos uma CPU inteira como "não ociosa", ou seja, 100% do tempo em execução ou interrompida, mas aguardando IO (estado "iowait"). Não era.
- (Além disso, eu esperava ver o tempo de "iowait" corresponder aproximadamente ao tempo gasto em write(). Mas não pareceu fazer isso.)
Os resultados detalhados e o ambiente de teste são mostrados abaixo. Também é mostrado um teste alternativo, onde minha suposição se manteve. Nota: era necessário correr para perf statdentro perf trace, e não o contrário. Isso é detalhado aqui: "perf stat" (e "time" !) mostra resultados incorretos ao executar "perf trace -s" ?
Informações básicas sobre "iowait"
A seguir está a definição retirada da página de
sarmanual:%iowait:
Porcentagem de tempo em que a CPU ou CPUs ficaram ociosas durante o qual o sistema teve uma solicitação de E/S de disco pendente.
Portanto, %iowait significa que, do ponto de vista da CPU, nenhuma tarefa foi executada, mas pelo menos uma E/S estava em andamento. iowait é simplesmente uma forma de tempo ocioso quando nada pode ser agendado. O valor pode ou não ser útil para indicar um problema de desempenho, mas informa ao usuário que o sistema está ocioso e poderia ter tido mais trabalho.
https://support.hpe.com/hpsc/doc/public/display?docId=c02783994
Há também um artigo mais longo: Entendendo a espera de E/S (ou por que 0% ocioso pode ser OK) . Isso explica como você pode ver a definição claramente a partir do código do kernel. O código mudou um pouco, mas a ideia ainda é clara:
/*
* Account for idle time.
* @cputime: the CPU time spent in idle wait
*/
void account_idle_time(u64 cputime)
{
u64 *cpustat = kcpustat_this_cpu->cpustat;
struct rq *rq = this_rq();
if (atomic_read(&rq->nr_iowait) > 0)
cpustat[CPUTIME_IOWAIT] += cputime;
else
cpustat[CPUTIME_IDLE] += cputime;
}
O artigo também mostra vários experimentos relacionados em um sistema de CPU única. Alguns dos experimentos até usam ddcom if=/dev/urandom ! No entanto, os experimentos não incluem meu teste dd if=/dev/urandom of=test.out . Ele só usa dd if=/dev/urandom of=/dev/null .
"IO wait" é um pouco mais complicado de pensar agora porque usamos sistemas multi-CPU, mas acho que ainda entendo, com base no código citado.
Meio Ambiente
Eu tenho quatro CPUs lógicas.
Eu uso o LVM e o sistema de arquivos ext4. Não estou usando nenhuma criptografia no meu disco ou sistema de arquivos. Eu não tenho nenhum sistema de arquivos de rede montado, então não estou lendo ou escrevendo um sistema de arquivos de rede.
Os resultados abaixo são do kernel 4.20.15-200.fc29.x86_64, usando o noopagendador de E/S. O cfqagendador de E/S também fornece resultados semelhantes.
(Eu também vi resultados semelhantes em uma compilação do kernel que foi baseada em uma configuração semelhante, mas estava mais próxima da versão 5.1 do kernel e usando mq-deadline. Então, isso estava usando o novo blk-mqcódigo).
Teste e resultados
$ sudo perf trace -s \
perf stat \
dd if=/dev/urandom of=test.out bs=1M oflag=direct count=3000
3000+0 records in
3000+0 records out
3145728000 bytes (3.1 GB, 2.9 GiB) copied, 31.397 s, 100 MB/s
Performance counter stats for 'dd if=/dev/urandom of=test.out bs=1M oflag=direct count=3000':
18,014.26 msec task-clock # 0.574 CPUs utilized
3,199 context-switches # 0.178 K/sec
4 cpu-migrations # 0.000 K/sec
328 page-faults # 0.018 K/sec
45,232,163,658 cycles # 2.511 GHz
74,538,278,379 instructions # 1.65 insn per cycle
4,372,725,344 branches # 242.737 M/sec
4,650,429 branch-misses # 0.11% of all branches
31.398466725 seconds time elapsed
0.006966000 seconds user
17.910332000 seconds sys
Summary of events:
...
dd (4620), 12156 events, 12.0%
syscall calls total min avg max stddev
(msec) (msec) (msec) (msec) (%)
--------------- -------- --------- --------- --------- --------- ------
read 3007 17624.985 0.002 5.861 12.345 0.21%
write 3003 13722.837 0.004 4.570 179.928 2.63%
openat 12 0.371 0.002 0.031 0.267 70.36%
...
Eu li a iowaitfigura da wacoluna de vmstat. Você pode saber quando o teste está sendo executado observando a iocoluna ( bo= 1K blocos de saída).
$ vmstat 5
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 5126892 176512 1486060 0 0 1788 4072 321 414 4 4 83 9 0
1 0 0 5126632 176520 1485988 0 0 0 7 212 405 0 1 99 0 0
0 0 0 5126884 176520 1485988 0 0 0 0 130 283 0 0 99 0 0
0 0 0 5126948 176520 1485908 0 0 0 1 157 325 0 0 99 0 0
0 0 0 5126412 176520 1486412 0 0 115 0 141 284 0 0 99 0 0
0 2 0 5115724 176548 1487056 0 0 0 6019 18737 10733 3 6 89 2 0
1 0 0 5115708 176580 1487104 0 0 3 91840 1276 990 0 13 77 9 0
1 0 0 5115204 176600 1487128 0 0 2 91382 1382 1014 0 14 81 4 0
1 0 0 5115268 176636 1487084 0 0 4 88281 1257 901 0 14 83 3 0
0 1 0 5113504 177028 1487764 0 0 77 92596 1374 1111 0 15 83 2 0
1 0 0 5114008 177036 1487768 0 0 0 113282 1460 1060 0 16 81 2 0
1 0 0 5113472 177044 1487792 0 0 0 110821 1489 1118 0 16 74 10 0
0 0 0 5123852 177068 1487896 0 0 0 20537 631 714 1 3 94 2 0
0 0 0 5123852 177076 1487856 0 0 0 10 324 529 2 1 98 0 0
2 0 0 5123852 177084 1487872 0 0 0 70 150 299 0 0 99 0 0
Resultados do teste onde ele se mantém (dentro de uma VM)
Eu tentei o mesmo teste dentro de uma VM com 1 CPU, que estava executando o kernel 5.0.9-301.fc30.x86_64e usando mq-deadline(e, portanto, blk-mq). Neste teste, funcionou como eu esperava.
$ sudo perf trace -s \
perf stat \
dd if=/dev/urandom of=test.out bs=1M oflag=direct count=3000
[sudo] password for alan-sysop:
3000+0 records in
3000+0 records out
3145728000 bytes (3.1 GB, 2.9 GiB) copied, 46.8071 s, 67.2 MB/s
Performance counter stats for 'dd if=/dev/urandom of=test.out bs=1M oflag=direct count=3000':
18,734.89 msec task-clock # 0.400 CPUs utilized
16,690 context-switches # 0.891 K/sec
0 cpu-migrations # 0.000 K/sec
328 page-faults # 0.018 K/sec
<not supported> cycles
<not supported> instructions
<not supported> branches
<not supported> branch-misses
46.820355993 seconds time elapsed
0.011840000 seconds user
18.531449000 seconds sys
Summary of events:
...
dd (1492), 12156 events, 38.4%
syscall calls total min avg max stddev
(msec) (msec) (msec) (msec) (%)
--------------- -------- --------- --------- --------- --------- ------
write 3003 28269.070 0.019 9.414 5764.657 22.39%
read 3007 18371.469 0.013 6.110 14.848 0.53%
execve 6 10.399 0.012 1.733 10.328 99.18%
...
Saída de vmstat 5:
$ vmstat 5
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
r b swpd free buff cache si so bi bo in cs us sy id wa st
0 0 0 726176 52128 498508 0 0 2040 231 236 731 7 5 77 11 0
0 0 0 726176 52136 498508 0 0 0 10 25 46 0 0 99 1 0
0 0 0 726208 52136 498508 0 0 0 0 29 56 0 0 100 0 0
0 1 0 702280 55944 511780 0 0 2260 13109 4399 9049 3 17 55 25 0
0 1 0 701776 56040 511960 0 0 18 129582 1406 1458 0 73 0 27 0
0 2 0 701524 56156 512168 0 0 22 87060 960 991 0 50 0 50 0
3 1 0 701524 56228 512328 0 0 14 118170 1301 1322 0 68 0 32 0
1 1 0 701272 56260 512392 0 0 6 86426 994 982 0 53 0 46 0
0 2 0 701020 56292 512456 0 0 6 56115 683 660 0 37 0 63 0
3 2 0 700540 56316 512504 0 0 5 33450 446 457 0 26 0 74 0
0 2 0 700860 56332 512536 0 0 3 16998 311 240 0 19 0 81 0
1 2 0 700668 56368 512616 0 0 7 32563 443 428 0 24 0 76 0
1 0 0 700668 56392 512648 0 0 3 20338 245 272 0 12 0 88 0
0 1 0 707096 56408 512920 0 0 54 20913 312 530 0 12 79 8 0
0 0 0 707064 56432 512920 0 0 0 49 39 64 0 0 45 55 0
0 0 0 707064 56432 512920 0 0 0 0 24 46 0 0 100 0 0
0 0 0 707064 56432 512920 0 0 0 80 28 47 0 0 100 0 0
Eu tentei adicionar uma CPU à VM e testar novamente. Os resultados foram variáveis: às vezes ele mostrava cerca de 0% na coluna ociosa e às vezes mostrava cerca de 50% ocioso (ou seja, uma em cada duas CPUs). No caso de 0% "idle", "iowait" foi muito alto, ou seja, vale mais de uma CPU. Ou seja, meu ponto de expectativa 2 não estava correto. Posso aceitar de má vontade esta aparente limitação de "iowait" em sistemas multi-CPU. (Embora eu não entenda muito bem. Se alguém quiser explicar exatamente, seria ótimo). No entanto, "idle" não estava acima de 50% em nenhum dos casos, portanto, esses testes ainda eram consistentes com minha primeira suposição sobre "iowait".
Eu tentei desligar a VM e iniciá-la com 4 CPUs. Da mesma forma, muitas vezes eu tinha exatamente 75% ocioso, e às vezes eu tinha tão baixo quanto 50% ocioso, mas não vi mais de 75% ocioso (ou seja, mais de três de quatro CPUs).
Já no sistema físico com 4 CPUs, ainda consigo reproduzir o resultado de mais de 80% de ociosidade conforme mostrado acima.
Eu preciso fazer algum trabalho em 700 dispositivos de rede usando um script de espera. Eu posso fazê-lo sequencialmente, mas até agora o tempo de execução é de cerca de 24 horas. Isso se deve principalmente ao tempo que leva para estabelecer uma conexão e ao atraso na saída desses dispositivos (antigos). Eu sou capaz de estabelecer duas conexões e executá-las em paralelo muito bem, mas até onde posso empurrar isso?
Eu não imagino que eu poderia fazer todos os 700 de uma vez, certamente há algum limite para o não. de conexões telnet que minha VM pode gerenciar.
Se eu tentasse iniciar 700 deles em algum tipo de loop como este:
for node in `ls ~/sagLogs/`; do
foo &
done
Com
CPU 12 CPUs x Intel(R) Xeon(R) CPU E5649 @ 2.53GHz
Memória 47,94 GB
Minha pergunta é:
- Todas as 700 instâncias poderiam ser executadas simultaneamente?
- Até onde eu poderia chegar até meu servidor atingir seu limite?
- Quando esse limite for atingido, ele apenas esperará para iniciar a próxima iteração
fooou a caixa travará?
Infelizmente, estou executando em um ambiente de produção corporativo, então não posso simplesmente tentar e ver o que acontece.
Eu quero criar um link simbólico
~/.pm2/logs -> /opt/myapp/log
Quando eu corro
ln -sFf /opt/myapp/log ~/.pm2/logs
eu recebo um link simbólico
~/.pm2/logs/log -> /opt/myapp/log
que não é o que eu quero.
Eu preferiria uma solução compatível com POSIX, se possível.
Isso funciona em um prompt do shell (bash, dash):
[ -z "" ] && echo A || echo B
A
No entanto, estou tentando escrever um script de shell POSIX , ele começa assim:
#!/bin/sh
[ "${#}" -eq 1 ] || echo "Invalid number of arguments, expected one."; exit 1
readonly raw_input_string=${1}
[ -z "${raw_input_string}" ] && echo "The given argument is empty."; exit 1
E não sei porque, mas não recebo a mensagem :
O argumento fornecido está vazio.
se eu chamar o script assim:
./test_empty_argument ""
Por que é que?
Eu uso um comando ProxyJump para várias sessões ssh que uso diariamente, e também troco muito de usuário nessas sessões e ter que digitar exit3 ou 4 vezes seguidas não é muito divertido.
Estou ciente de newline+ ~+ .para encerrar uma sessão ssh, ainda tenho que verificar se ela termina amigavelmente como exitfaria, mas como você sai de todas as sessões no shell atual com um único comando ou atalho, digitando exit3 ou 4 vezes no meu caso se torna uma coisa única?
Ao executar e2fsck -cck /dev/mapper/xxx sou solicitado com
has 487 multiply-claimed block(s), shared with 84 file(s):
... (inode #221446306, mod time Tue Feb 20 19:48:38 2018)
... (inode #221446305, mod time Tue Feb 20 19:48:32 2018)
... (inode #221446304, mod time Tue Feb 20 19:48:38 2018)
... (inode #221446303, mod time Tue Feb 20 19:48:12 2018)
... (inode #221446302, mod time Tue Feb 20 19:59:04 2018)
... (inode #221446300, mod time Tue Feb 20 19:47:52 2018)
Clone multiply-claimed blocks<y>?
Qual será a possível consequência de continuar com o sim. Haverá perda total de dados? Qual é o resultado se continuar com não?
Existem dados JSON que contêm alguns valores numéricos. Como converter todos os números em strings? (enrole com aspas)
Exemplo:
{
"id":1,
"customer":"user",
"plate":"BMT-216-A",
"country":"GB",
"amount":1000,
"pndNumber":20000,
"zoneNumber":4
}
Deve se tornar
{
"id":"1",
"customer":"user",
"plate":"BMT-216-A",
"country":"GB",
"amount":"1000",
"pndNumber":"20000",
"zoneNumber":"4"
}
Geralmente usamos $@para representar todos os argumentos, exceto $0. No entanto, não sei o que $@é estrutura de dados.
Por que se comporta de maneira diferente $*ao incluir aspas duplas, alguém poderia me dar uma explicação no nível do intérprete?
Ele pode ser iterado em loop for, então parece ser array. No entanto, também pode ecoar inteiramente com simple echo $@, se for uma matriz, apenas o primeiro elemento será mostrado. Devido à limitação do shell, não posso escrever mais código de experimento para realizá-lo.
Diferença entre este post : Este post mostra como $@se comporta de forma diferente do $*. Mas eu estou querendo saber sobre o tipo de dados de $@. Shell como linguagem de interpretação, como Python, deve representar dados de acordo com uma série de tipos fundamentais. Ou em outras palavras, quero saber como $@ é armazenado na memória do computador.
É uma string, uma string de várias linhas ou uma matriz?
Se for um tipo de dados exclusivo, é possível definir uma variável personalizada como uma instância desse tipo?
Eu preciso disso para um teste de unidade. Existe uma função que faz lstat no caminho do arquivo passado como parâmetro. Eu tenho que acionar o caminho do código onde lstatfalha (porque a cobertura do código tem que chegar a 90%)
O teste pode ser executado apenas em um único usuário, portanto, eu queria saber se há um arquivo no Ubuntu que sempre existe, mas os usuários normais não têm acesso de leitura a ele ou à sua pasta. (Então lstat, falharia, a menos que fosse executado como root.)
Um arquivo inexistente não é uma solução, porque existe um caminho de código separado para isso, que já estou acionando.
EDIT: A falta de acesso de leitura ao arquivo apenas não é suficiente. Com isso lstatainda pode ser executado. Consegui acioná-lo (na minha máquina local, onde tenho acesso root), criando uma pasta em /root e um arquivo nela. E definindo a permissão 700 na pasta. Então, estou procurando um arquivo que está em uma pasta que só é acessível pelo root.