Como calcular MIPS para um algoritmo para processador ARM

StackOverflow https://stackoverflow.com/questions/678771

  •  21-08-2019
  •  | 
  •  

Pergunta

Tenho sido perguntado recentemente produziu os MIPS (milhões de instruções por segundo) para um algoritmo que desenvolvemos. O algoritmo é exposta por um conjunto de funções de estilo C. Temos exercer o código em um Dell Axim para aferir o desempenho sob entrada diferente.

Esta questão veio do nosso fornecedor de hardware, mas sou principalmente um desenvolvedor de software HL então eu não sei como responder ao pedido. Talvez alguém com semelhante fundo HW / SW pode ajudar ...

  1. Uma vez que o nosso algoritmo não é em tempo real, eu não acho que nós precisamos quantificá-lo como MIPS. É possível simplesmente citar o número total de instruções de montagem?

  2. Se 1 é verdade, como você faz isso (ie. A forma de medir o número de instruções de montagem) em geral ou especificamente para ARM / XScale?

  3. Can 2 ser executado em um dispositivo WM ou através do Device Emulator previsto no VS2005?

  4. Can 3 ser automatizado?

Muito obrigado pela sua ajuda. Charles

Obrigado por toda sua ajuda. Acho S.Lott bater o prego. E como um acompanhamento, agora tenho mais perguntas.

5 Qualquer sugestão sobre como proceder para medição MIPS? Ouvi alguém sugerir executando nosso algoritmo e comparando-a com Dhrystone / Whetstone referência para calcular MIS.

6 Desde o algoritmo não precisa ser executado em tempo real, é MIPS realmente uma medida útil? (Eg. Factorial (N)) Quais são outras maneiras de quantidade os requisitos de processamento? (Eu já mediu o desempenho de tempo de execução, mas não era uma resposta satisfatória.)

7 Finalmente, eu assumo MIPS é uma estimativa grosseira e seria dep. no compilador, configurações de otimização, etc?

Foi útil?

Solução

Eu aposto que o seu fornecedor de hardware está perguntando quantos MIPS você precisa.

Como em "Você precisa de um processador MIPS 1000 ou um processador de 2.000 MIPS?"

Qual é traduzido pela administração para "Quantos MIPS?"

ofertas de hardware MIPS. consome software MIPS.

Você tem dois graus de liberdade.

  • inerente oferta MIPS do processador.

  • O número de segundos durante os quais você consumir que muitas MIPS.

Se o processador não tem MIPS suficientes, seu algoritmo será "lento".

Se o processador tem MIPS suficientes, seu algoritmo será "rápido".

Eu coloquei "rápido" e "lento" entre aspas porque você precisa ter um requisito de desempenho para determinar "rápido o suficiente para atender os requisitos de desempenho" ou "lento demais para atender o requisito de desempenho."

Em um processador de 2.000 MIPS, você pode levar um aceitáveis ??2 segundos. Mas em um processador MIPS 1000 este explode para um inaceitáveis ??4 segundos.

Como muitos MIPS você precisa?

  1. Obter os MIPS oficiais para seu processador. Consulte http://en.wikipedia.org/wiki/Instructions_per_second

  2. Executar o seu algoritmo sobre alguns dados.

  3. Medir o tempo de execução exato. um grupo média de amostras para reduzir a incerteza.

  4. Relatório. 3 segundos em um processador 750 MIPS é - bem - 3 segundos em 750 MIPS. MIPS é uma taxa. O tempo é tempo. Distância é o produto da taxa * tempo. 3 segundos em 750 MIPS é de 750 * 3 milhões de instruções.

Lembre-Rate (em instruções por segundo) * Tempo (em segundos) dá-lhe instruções.

Não diga que é 3 * 750 MIPS. Não é; é 2250 milhões de instruções.

Outras dicas

Algumas notas:

  1. MIPS é frequentemente utilizado como uma medida geral "capacidade" para processadores, especialmente no campo macio em tempo real / embutido onde você quer garantir que você não sobrecarregar um processador com o trabalho. Note que este é instruções por segundo, como o tempo é muito importante!

  2. MIPS usados ??desta forma é muito científico.

  3. MIPS utilizados neste moda ainda é muitas vezes a melhor aproximação não é para dimensionamento de um sistema e determinar a velocidade do processador. Ele poderia muito bem estar fora por 25%, mas não importa ...

  4. Contando MIPS requer um processador que está perto do que você está usando. O conjunto de instruções direito é, obviamente, crucial para capturar o fluxo de instrução real do compilador real em uso.

Você não pode de forma alguma aproximar isso em um PC. Você precisa trazer para fora uma das poucas ferramentas para fazer isso mesmo:

  1. Use um simulador de instrução de conjunto para o archicture alvo tais como Qemu, próprias ferramentas da ARM, Synopsys, CoWare, Virtutech, ou vastas. Estes são rápidos, mas pode contar instruções muito bem, e apoiará o conjunto de instruções direita. Restrição de uso extensivo de instruções caros como divisão inteira (e por favor, não de ponto flutuante), esses números tendem a ser útil perto.

  2. Encontre um relógio de ciclo simulador precisa para o seu processador de destino (ou algo próximo), o que dará muito boa estimativa de efeitos de oleodutos etc. Mais uma vez, começar a partir de ARM ou de carbono SoCDesigner.

  3. Obter uma placa de desenvolvimento para a família de processadores que são alvo, ou um ARM próximo a ela projetar e traçar o perfil do aplicativo lá. Você não usar um ARM9 de perfil para um ARM11, mas um ARM11 pode ser uma boa aproximação para um ARM Cortex-A8 / A9, por exemplo.

MIPS é geralmente usado para medir a capacidade de um processador.

Algoritmos geralmente optar quer:

  1. um determinado período de tempo (durante a execução em um determinado processador)
  2. um certo número de instruções (dependendo da arquitetura)

Ao descrever um algoritmo em termos de instruções por segundo parece ser uma medida estranha, mas é claro que eu não sei o que o seu algoritmo faz.

Para chegar a uma medida significativa, gostaria de sugerir que você configurar um teste que permite medir o tempo médio necessário para o seu algoritmo para ser concluído. Número de instruções de montagem seria uma medida razoável, mas pode ser difícil contá-los! Sua melhor aposta é algo como isto (pseudo-código): 

const num_trials = 1000000
start_time = timer()
for (i = 1 to num_trials)
{
    runAlgorithm(randomData)
}
time_taken = timer() - start_time
average_time = time_taken / num_trials

MIPS são uma medida da velocidade da CPU, não algoritmo de desempenho. Eu só posso assumir a algum lugar ao longo da linha, alguém está um pouco confuso. O que eles estão tentando descobrir? O cenário só é provável que eu posso pensar é que eles estão tentando ajudar a determinar quão rápido um processador de que precisam para dar-lhe para executar o programa de forma satisfatória.

Uma vez que você pode medir um algoritmo no número de instruções (que é, sem dúvida, vai depender dos dados de entrada, de modo que este não é trivial), então você precisa de alguma medida de tempo a fim de obter MIPS - por exemplo, , dizer "eu preciso chamá-lo 1.000 vezes por segundo". Se o seu algoritmo é 1000 instruções para que caso particular, você vai acabar com: 

1000 instructions / (1/1000) seconds = 1000000 instructions per second = 1 MIPS.

Eu ainda acho que é uma maneira muito estranha para tentar fazer as coisas, então você pode querer pedir esclarecimentos. Quanto a suas perguntas específicas, eu vou deixar isso para alguém mais familiarizado com o Visual Studio.

Lembre-se também que diferentes compiladores e opções do compilador fazer uma enorme diferença. O mesmo código-fonte pode ser executado em muitas velocidades diferentes. Então, em vez de comprar o processador 2mips você pode ser capaz de usar o / 2mips processador de 1 e usar uma opção do compilador. Ou gastar o dinheiro em um compilador melhor e usar o processador mais barato.

O benchmarking é falho na melhor das hipóteses. Como um hobby que eu usei para compilar o mesmo Dhrystone (e pedra de amolar) código em vários compiladores de vários fornecedores para o mesmo hardware e os números estavam em todo o lugar, ordens de magnitude. Mesmo código fonte mesmo processador, Dhrystone não quis dizer uma coisa, não é útil como uma linha de base. O que importa na análise comparativa é o quão rápido é que o seu algoritmo prazo, é melhor que seja tão ou mais rápido do que ele precisa. Dependendo de como perto da linha de chegada você é permitir que a abundância de despejos. Logo no início on provavelmente vai querer estar executando 5 ou 10 ou 100 vezes mais rápido do que você precisa para que até o final do projeto que são pelo menos um pouco mais rápido do que você precisa para ser.

Eu concordo com o que eu penso S. Lott está dizendo, isto é todas as vendas e marketing e gestão de conversa. Sendo aquele que a administração colocou entre uma rocha eo lugar duro, então o que você precisa fazer é levá-los a comprar o processador mais rápido e melhores ferramentas de que eles estão dispostos a gastar com base nos gráficos de pizza coloridos e gráficos que você está indo para gerar a partir do ar como justificação. Se perto do fim da estrada esquentar desempenho bastante se encontram, então você pode voltar para stackoverflow, mas ao mesmo tempo a gestão será forçado a comprar um conjunto de ferramentas diferentes em quase todos os processadores de preços ou de swap e respin a bordo. Até então você deve saber como perto do alvo que você é, precisamos 1.0 e estamos em 1,25 se comprar o processador que é duas vezes mais rápido como o que comprei devemos fazê-lo.

Quer ou não você pode automatizar esses tipos de coisas ou simulá-los depende das ferramentas, às vezes sim, às vezes não. Eu não estou familiarizado com as ferramentas que você está falando sobre isso não posso falar diretamente com eles.

Esta resposta não se destina a responder a pergunta diretamente, mas para fornecer contexto adicional em torno de por que esta pergunta é respondida.

MIPS para um algoritmo só é relevante para algoritmos que precisam responder a um evento dentro do tempo exigido.

Por exemplo, considere um controlador projetado para detectar a velocidade do vento e mover o atuador dentro de um segundo, quando as cruzes velocidade do vento mais de 25 milhas / hora. Digamos que leva 1000 instruções para calcular e comparar a velocidade do vento contra o limiar. A exigência MIPS para este algoritmo é 1 quilo de Instruções Por Segundo (kips). Se o controlador é baseado no processador 1 MIPS, podemos confortavelmente dizer que não há mais suco no controlador para adicionar outras funções.

Que outras funções poderiam ser adicionados no controlador? Isso depende dos MIPS da função / algoritmo para ser adicionado. Se houver outra função que precisa de 100.000 instruções a serem executadas dentro de um segundo (ou seja, 100 Kips), ainda podemos acomodar esta nova função e ainda tem algum espaço para outras funções para adicionar.

Para uma primeira estimativa uma referência no PC pode ser útil.

No entanto, antes de se comprometer com uma frequência de dispositivo específico e relógio você deve ter uma placa de desenvolvedor (ou algum PDA?) Para a arquitetura ARM-alvo e referência-lo lá.

Há uma série de fatores que influenciam a velocidade em máquinas de hoje (caching, oleodutos, diferentes conjuntos de instruções, ...) para que seus benchmarks em um PC pode ser a maneira fora w.r.t. o ARM.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top