É if( a < 901 )mais rápido que if( a <= 900 ).

Não é exatamente como neste exemplo simples, mas há pequenas alterações de desempenho no código complexo de loop. Suponho que isso tenha algo a ver com o código de máquina gerado, caso isso seja verdade.

Não, não será mais rápido na maioria das arquiteturas. Você não especificou, mas no x86, todas as comparações integrais serão normalmente implementadas em duas instruções da máquina:

• A testou cmpinstrução, que defineEFLAGS
• E uma Jccinstrução (jump) , dependendo do tipo de comparação (e layout do código):
  • jne - Salte se não for igual -> ZF = 0
  • jz - Salte se zero (igual) -> ZF = 1
  • jg - Salte se maior -> ZF = 0 and SF = OF
  • (etc ...)

Exemplo (Editado por brevidade) Compilado com$ gcc -m32 -S -masm=intel test.c

    if (a < b) {
        // Do something 1
    }

Compila para:

    mov     eax, DWORD PTR [esp+24]      ; a
    cmp     eax, DWORD PTR [esp+28]      ; b
    jge     .L2                          ; jump if a is >= b
    ; Do something 1
.L2:

E

    if (a <= b) {
        // Do something 2
    }

Compila para:

    mov     eax, DWORD PTR [esp+24]      ; a
    cmp     eax, DWORD PTR [esp+28]      ; b
    jg      .L5                          ; jump if a is > b
    ; Do something 2
.L5:

Portanto, a única diferença entre os dois é jguma jgeinstrução versus uma instrução. Os dois levarão a mesma quantidade de tempo.

Gostaria de abordar o comentário de que nada indica que as diferentes instruções de salto levam a mesma quantidade de tempo. Este é um pouco complicado de responder, mas eis o que posso dar: Na Referência do conjunto de instruções da Intel , todos estão agrupados sob uma instrução comum Jcc(Salte se a condição for atendida). O mesmo agrupamento é feito em conjunto no Manual de Referência da Otimização , no Apêndice C. Latência e Taxa de Transferência.

Latência - O número de ciclos de clock necessários para o núcleo de execução concluir a execução de todos os µops que formam uma instrução.

Taxa de transferência - O número de ciclos de clock necessários para aguardar antes que as portas de emissão estejam livres para aceitar a mesma instrução novamente. Para muitas instruções, o rendimento de uma instrução pode ser significativamente menor que sua latência

Os valores para Jccsão:

      Latency   Throughput
Jcc     N/A        0.5

com a seguinte nota de rodapé Jcc:

7) A seleção das instruções de salto condicional deve ser baseada na recomendação da seção 3.4.1, “Otimização de previsão de ramificação”, para melhorar a previsibilidade das ramificações. Quando as ramificações são previstas com sucesso, a latência de jccé efetivamente zero.

Portanto, nada nos documentos da Intel trata uma Jccinstrução de maneira diferente das outras.

Se pensarmos nos circuitos reais usados ​​para implementar as instruções, podemos assumir que haveria portas AND / OR simples nos diferentes bits EFLAGS, para determinar se as condições são atendidas. Portanto, não há razão para que uma instrução que teste dois bits deva levar mais ou menos tempo do que uma que teste apenas um (Ignorando o atraso de propagação da porta, que é muito menor que o período do relógio).

Editar: Ponto flutuante

Isso também vale para o ponto flutuante x87: (Praticamente o mesmo código acima, mas com em doublevez de int.)

        fld     QWORD PTR [esp+32]
        fld     QWORD PTR [esp+40]
        fucomip st, st(1)              ; Compare ST(0) and ST(1), and set CF, PF, ZF in EFLAGS
        fstp    st(0)
        seta    al                     ; Set al if above (CF=0 and ZF=0).
        test    al, al
        je      .L2
        ; Do something 1
.L2:

        fld     QWORD PTR [esp+32]
        fld     QWORD PTR [esp+40]
        fucomip st, st(1)              ; (same thing as above)
        fstp    st(0)
        setae   al                     ; Set al if above or equal (CF=0).
        test    al, al
        je      .L5
        ; Do something 2
.L5:
        leave
        ret

Historicamente (estamos falando dos anos 80 e início dos 90), havia algumas arquiteturas nas quais isso era verdade. O problema principal é que a comparação de números inteiros é inerentemente implementada por meio de subtrações de números inteiros. Isso dá origem aos seguintes casos.

Comparison     Subtraction
----------     -----------
A < B      --> A - B < 0
A = B      --> A - B = 0
A > B      --> A - B > 0

Agora, quando A < Ba subtração precisar emprestar um valor alto para que a subtração esteja correta, assim como você carrega e empresta ao adicionar e subtrair manualmente. Esse bit "emprestado" era geralmente chamado de bit de transporte e seria testável por uma instrução de ramificação. Um segundo bit chamado zero seria definido se a subtração fosse idêntica a zero, o que implicava igualdade.

Geralmente, havia pelo menos duas instruções de ramificação condicional, uma para ramificar no bit de transporte e outra no bit zero.

Agora, para chegar ao cerne da questão, vamos expandir a tabela anterior para incluir os resultados carry e zero bit.

Comparison     Subtraction  Carry Bit  Zero Bit
----------     -----------  ---------  --------
A < B      --> A - B < 0    0          0
A = B      --> A - B = 0    1          1
A > B      --> A - B > 0    1          0

Portanto, implementar uma ramificação para A < Bpode ser feito em uma instrução, porque o bit de transporte é claro apenas neste caso, ou seja,

;; Implementation of "if (A < B) goto address;"
cmp  A, B          ;; compare A to B
bcz  address       ;; Branch if Carry is Zero to the new address

Mas, se quisermos fazer uma comparação menor ou igual, precisamos fazer uma verificação adicional do sinalizador zero para entender o caso da igualdade.

;; Implementation of "if (A <= B) goto address;"
cmp A, B           ;; compare A to B
bcz address        ;; branch if A < B
bzs address        ;; also, Branch if the Zero bit is Set

Portanto, em algumas máquinas, o uso de uma comparação "menor que" pode salvar uma instrução da máquina . Isso foi relevante na era da velocidade do processador sub-megahertz e na proporção de 1: 1 da CPU para a memória, mas hoje é quase totalmente irrelevante hoje.

Supondo que estamos falando de tipos inteiros internos, não há como um ser mais rápido que o outro. Eles são obviamente semanticamente idênticos. Ambos pedem que o compilador faça exatamente a mesma coisa. Somente um compilador horrivelmente quebrado geraria código inferior para um deles.

Se houver alguma plataforma <mais rápida do que <=para tipos inteiros simples, o compilador deve sempre converter <=para <para constantes. Qualquer compilador que não o fizesse seria apenas um compilador ruim (para essa plataforma).

Vejo que nem é mais rápido. O compilador gera o mesmo código de máquina em cada condição com um valor diferente.

if(a < 901)
cmpl  $900, -4(%rbp)
jg .L2

if(a <=901)
cmpl  $901, -4(%rbp)
jg .L3

Meu exemplo if é do GCC na plataforma x86_64 no Linux.

Os escritores de compiladores são pessoas bastante inteligentes, e pensam nessas coisas e em muitas outras que a maioria de nós considera um dado adquirido.

Percebi que, se não for uma constante, o mesmo código de máquina será gerado nos dois casos.

int b;
if(a < b)
cmpl  -4(%rbp), %eax
jge   .L2

if(a <=b)
cmpl  -4(%rbp), %eax
jg .L3

Para código de ponto flutuante, a comparação <= pode realmente ser mais lenta (por uma instrução), mesmo em arquiteturas modernas. Aqui está a primeira função:

int compare_strict(double a, double b) { return a < b; }

No PowerPC, primeiro isso faz uma comparação de ponto flutuante (que atualiza cr , o registro de condições), depois move o registro de condições para um GPR, muda o bit "comparado menos que" para o local e depois retorna. São necessárias quatro instruções.

Agora considere esta função:

int compare_loose(double a, double b) { return a <= b; }

Isso requer o mesmo trabalho que o compare_strictdescrito acima, mas agora há dois bits de interesse: "era menor que" e "era igual a". Isso requer uma instrução extra ( cror- registro de condição OR bit a bit) para combinar esses dois bits em um. Portanto, compare_looserequer cinco instruções, enquanto compare_strictrequer quatro.

Você pode pensar que o compilador pode otimizar a segunda função da seguinte maneira:

int compare_loose(double a, double b) { return ! (a > b); }

No entanto, isso irá lidar incorretamente com NaNs. NaN1 <= NaN2e NaN1 > NaN2precisa avaliar como falso.

Talvez o autor desse livro sem nome tenha lido que a > 0corre mais rápido do que a >= 1e pensa que isso é verdade universalmente.

Mas é porque a 0está envolvido (porque CMPpode, dependendo da arquitetura, substituído, por exemplo, por OR) e não por causa do <.

No mínimo, se isso fosse verdade, um compilador poderia otimizar trivialmente a <= b para! (A> b) e, mesmo que a comparação em si fosse realmente mais lenta, com todos, exceto o compilador mais ingênuo, você não notaria diferença .

Eles têm a mesma velocidade. Talvez em alguma arquitetura especial o que ele disse esteja certo, mas na família x86 pelo menos eu sei que eles são iguais. Porque, para fazer isso, a CPU fará uma subtração (a - b) e depois verificará os sinalizadores do registro do sinalizador. Dois bits desse registrador são chamados ZF (sinalizador zero) e SF (sinalizador), e são feitos em um ciclo, porque o fazem com uma operação de máscara.

Isso seria altamente dependente da arquitetura subjacente na qual o C é compilado. Alguns processadores e arquiteturas podem ter instruções explícitas para igual ou menor que e igual a, que são executadas em diferentes números de ciclos.

Isso seria bastante incomum, pois o compilador poderia contorná-lo, tornando-o irrelevante.

TL; DRResposta

Para a maioria das combinações de arquitetura, compilador e idioma, não será mais rápido.

Resposta completa

Outras respostas se concentraram em arquitetura x86 , e eu não conheço bem a arquitetura ARM (que seu assembler de exemplo parece) o suficiente para comentar especificamente sobre o código gerado, mas este é um exemplo de micro-otimização que é muito arquitetura específico e é tão provável que seja uma anti-otimização quanto uma otimização .

Como tal, eu sugeriria que esse tipo de micro-otimização é um exemplo de culto à carga programação de , e não das melhores práticas de engenharia de software.

Provavelmente existem algumas arquiteturas em que isso é uma otimização, mas eu sei de pelo menos uma arquitetura em que o oposto pode ser verdadeiro. A venerável arquitetura do Transputer tinha apenas instruções de código de máquina iguais ou maiores que ou iguais a , portanto todas as comparações tiveram que ser construídas a partir dessas primitivas.

Mesmo assim, em quase todos os casos, o compilador podia ordenar as instruções de avaliação de tal maneira que, na prática, nenhuma comparação tivesse vantagem sobre outras. No pior caso, pode ser necessário adicionar uma instrução reversa (REV) para trocar os dois itens principais na pilha de operandos . Essa era uma instrução de byte único que demorou um único ciclo para ser executada, assim teve a menor sobrecarga possível.

Se uma micro-otimização como essa é uma otimização ou uma anti-otimização depende da arquitetura específica que você está usando, por isso é geralmente uma má idéia adquirir o hábito de usar micro-otimizações específicas da arquitetura; caso contrário, você pode instintivamente use um quando for inapropriado e parece que é exatamente isso que o livro que você está lendo está defendendo.

Você não deve perceber a diferença, mesmo que exista. Além disso, na prática, você terá que fazer um adicional a + 1ou a - 1manter a condição, a menos que use algumas constantes mágicas, o que é uma prática muito ruim em todos os aspectos.

Você poderia dizer que a linha está correta na maioria das linguagens de script, pois o caractere extra resulta em um processamento de código um pouco mais lento. No entanto, como a resposta principal apontou, ela não deve ter efeito em C ++, e qualquer coisa que esteja sendo feita com uma linguagem de script provavelmente não está preocupada com a otimização.

Quando eu escrevi essa resposta, eu só estava olhando para a pergunta do título sobre <vs. <= em geral, não é o exemplo específico de uma constante a < 901vs. a <= 900. Muitos compiladores sempre diminuem a magnitude das constantes convertendo entre <e <=, por exemplo, porque o operando imediato x86 possui uma codificação de 1 byte mais curta para -128..127.

Para o ARM e especialmente o AArch64, a capacidade de codificação imediata depende da capacidade de rotacionar um campo estreito para qualquer posição em uma palavra. Então, cmp w0, #0x00f000seria codificável, enquanto cmp w0, #0x00effffpode não ser. Portanto, a regra de redução do tamanho para comparação versus uma constante em tempo de compilação nem sempre se aplica ao AArch64.

<vs. <= em geral, inclusive para condições variáveis ​​de tempo de execução

Na linguagem assembly na maioria das máquinas, uma comparação para <=tem o mesmo custo que uma comparação para <. Isso se aplica se você estiver ramificando-o, fazendo booleano para criar um número inteiro 0/1 ou usando-o como predicado para uma operação de seleção sem ramificação (como x86 CMOV). As outras respostas abordaram apenas essa parte da pergunta.

Mas esta pergunta é sobre os operadores C ++, a entrada para o otimizador. Normalmente, ambos são igualmente eficientes; o conselho do livro parece totalmente falso porque os compiladores sempre podem transformar a comparação que eles implementam em asm. Mas há pelo menos uma exceção em que o uso <=pode criar acidentalmente algo que o compilador não pode otimizar.

Como condição de loop, há casos em que <=é qualitativamente diferente de <, quando impede o compilador de provar que um loop não é infinito. Isso pode fazer uma grande diferença, desativando a vetorização automática.

O estouro não assinado é bem definido como base 2, ao contrário do UB (estouro assinado). Os contadores de loop assinados geralmente estão seguros disso com os compiladores que otimizam com base no UB de overflow com sinal não acontecendo: ++i <= sizesempre acabará sempre se tornando falso. ( O que todo programador C deve saber sobre comportamento indefinido )

void foo(unsigned size) {
    unsigned upper_bound = size - 1;  // or any calculation that could produce UINT_MAX
    for(unsigned i=0 ; i <= upper_bound ; i++)
        ...

Os compiladores só podem otimizar de maneira a preservar o comportamento (definido e legalmente observável) da fonte C ++ para todos os possíveis valores de entrada , exceto aqueles que levam a um comportamento indefinido.

(Um simples i <= sizetambém criaria o problema, mas pensei que calcular um limite superior era um exemplo mais realista de introduzir acidentalmente a possibilidade de um loop infinito para uma entrada que você não se importa, mas que o compilador deve considerar.)

Nesse caso, size=0leva a upper_bound=UINT_MAXe i <= UINT_MAXé sempre verdade. Portanto, esse loop é infinito size=0, e o compilador deve respeitar isso, mesmo que você como programador provavelmente nunca pretenda passar size = 0. Se o compilador puder incorporar essa função em um chamador, onde poderá provar que size = 0 é impossível, então ótimo, ele poderá otimizar como poderia i < size.

Asm like if(!size) skip the loop; do{...}while(--size);é uma maneira normalmente eficiente de otimizar um for( i<size )loop, se o valor real de inão for necessário dentro do loop ( por que os loops são sempre compilados no estilo "do ... while" (salto de cauda)? ).

Mas isso não pode ser infinito: se inserido com size==0, obtemos 2 ^ n iterações. (A iteração sobre todos os números inteiros não assinados em um loop C torna possível expressar um loop sobre todos os números inteiros não assinados, incluindo zero, mas não é fácil sem um sinalizador carry do jeito que está no asm.)

Com a possibilidade de envolver o contador de loop, os compiladores modernos simplesmente "desistem" e não otimizam de maneira tão agressiva.

Exemplo: soma dos números inteiros de 1 a n

O uso de i <= nderrotas não assinadas derrota o reconhecimento de expressões idiomáticas do clang que otimiza sum(1 .. n)loops com um formulário fechado com base na n * (n+1) / 2fórmula de Gauss .

unsigned sum_1_to_n_finite(unsigned n) {
    unsigned total = 0;
    for (unsigned i = 0 ; i < n+1 ; ++i)
        total += i;
    return total;
}

x86-64 asm de clang7.0 e gcc8.2 no Godbolt compiler explorer

 # clang7.0 -O3 closed-form
    cmp     edi, -1       # n passed in EDI: x86-64 System V calling convention
    je      .LBB1_1       # if (n == UINT_MAX) return 0;  // C++ loop runs 0 times
          # else fall through into the closed-form calc
    mov     ecx, edi         # zero-extend n into RCX
    lea     eax, [rdi - 1]   # n-1
    imul    rax, rcx         # n * (n-1)             # 64-bit
    shr     rax              # n * (n-1) / 2
    add     eax, edi         # n + (stuff / 2) = n * (n+1) / 2   # truncated to 32-bit
    ret          # computed without possible overflow of the product before right shifting
.LBB1_1:
    xor     eax, eax
    ret

Mas para a versão ingênua, obtemos apenas um loop estúpido do clang.

unsigned sum_1_to_n_naive(unsigned n) {
    unsigned total = 0;
    for (unsigned i = 0 ; i<=n ; ++i)
        total += i;
    return total;
}

# clang7.0 -O3
sum_1_to_n(unsigned int):
    xor     ecx, ecx           # i = 0
    xor     eax, eax           # retval = 0
.LBB0_1:                       # do {
    add     eax, ecx             # retval += i
    add     ecx, 1               # ++1
    cmp     ecx, edi
    jbe     .LBB0_1            # } while( i<n );
    ret

O GCC não usa um formulário fechado de qualquer maneira, portanto a escolha da condição do loop não o prejudica ; vetoriza automaticamente com adição de número inteiro SIMD, executando 4 ivalores em paralelo nos elementos de um registro XMM.

# "naive" inner loop
.L3:
    add     eax, 1       # do {
    paddd   xmm0, xmm1    # vect_total_4.6, vect_vec_iv_.5
    paddd   xmm1, xmm2    # vect_vec_iv_.5, tmp114
    cmp     edx, eax      # bnd.1, ivtmp.14     # bound and induction-variable tmp, I think.
    ja      .L3 #,       # }while( n > i )

 "finite" inner loop
  # before the loop:
  # xmm0 = 0 = totals
  # xmm1 = {0,1,2,3} = i
  # xmm2 = set1_epi32(4)
 .L13:                # do {
    add     eax, 1       # i++
    paddd   xmm0, xmm1    # total[0..3] += i[0..3]
    paddd   xmm1, xmm2    # i[0..3] += 4
    cmp     eax, edx
    jne     .L13      # }while( i != upper_limit );

     then horizontal sum xmm0
     and peeled cleanup for the last n%3 iterations, or something.

Ele também possui um loop escalar simples que eu acho que ele usa para muito pequeno ne / ou para o caso de loop infinito.

BTW, esses dois loops desperdiçam uma instrução (e um uop nas CPUs da família Sandybridge) na sobrecarga do loop. sub eax,1/ em jnzvez de add eax,1/ cmp / jcc seria mais eficiente. 1 uop em vez de 2 (após a fusão macro de sub / jcc ou cmp / jcc). O código após os dois loops grava EAX incondicionalmente, portanto não está usando o valor final do contador de loops.

Somente se as pessoas que criaram os computadores forem ruins com lógica booleana. O que eles não deveriam ser.

Toda comparação ( >= <= > <) pode ser feita na mesma velocidade.

O que toda comparação é, é apenas uma subtração (a diferença) e ver se é positivo / negativo.
(Se msbestiver definido, o número é negativo)

Como verificar a >= b? Sub a-b >= 0Verifique se a-bé positivo.
Como verificar a <= b? Sub 0 <= b-aVerifique se b-aé positivo.
Como verificar a < b? Sub a-b < 0Verifique se a-bé negativo.
Como verificar a > b? Sub 0 > b-aVerifique se b-aé negativo.

Simplificando, o computador pode fazer isso por baixo do capô para a operação fornecida:

a >= b== msb(a-b)==0
a <= b== msb(b-a)==0
a > b== msb(b-a)==1
a < b==msb(a-b)==1

e, claro, o computador não seria realmente precisa fazer o ==0ou ==1qualquer um.
para o ==0que poderia apenas inverter o msbdo circuito.

Enfim, eles certamente não teriam feito a >= bser calculado como a>b || a==blol