¿Es> = más fácil de procesar para una PC que>?

Depende del tipo de operandos.

Si el tipo es una máquina de 32 bits o un entero de 64 bits -por ejemplo, un int o long en código C- (sentado en el registro, o tal vez caché L1), es exactamente el mismo tiempo (típicamente 0.3 a 0.5 nanosegundos, o tal vez 3 nanosegundos si en caché L1).

Si el tipo es algo más complejo compatible con el software (por ejemplo, números aritméticos de precisión arbitraria, también conocido como bignums), las cosas pueden cambiar mucho.

Si se trata de Javascript o Python o algunos lenguajes de tipo dinámico, la sobrecarga de interpretación es mucho más que la comparación en sí.

Si está compilado en C por un compilador optimizador (por ejemplo, gcc con el indicador -O2 ), debe confiar en su compilador (puede agregar -mcpu=native a su comando gcc ); sabe mejor que tu En la práctica, la programación de las instrucciones de la máquina y los errores de caché son muy importantes (y son mucho más importantes que la elección de una comparación individual de máquina <= vs <).

La declaración orred es exactamente una instrucción más corta.

¿Cúal? Una instrucción jmp.

Considere el siguiente programa

Si (var> 20 && var <50)
hacer cosas;

Podría compilarse en el siguiente pseudoensamblaje:

Cmp val 20
Jg bigenough
Jmp cont
Bigenough: cmp val 50
Jl smallenough
Jmp cont
Smallenough: haz cosas
Cont: …

… ¿Seriamente?

Cmp val 20
Jle cont
Cmp val 50
Jge cont
Hacer cosas
Cont: …

El segundo enfoque:

  • Es mas corto
  • Es más rápido
  • No descarga la tubería (dos saltos en lugar de cuatro), y
  • No vuela el caché.

No es que la instrucción de comparación sea más rápida, es solo que si (a) b; es más lento que si (! a) continúe; si;

<,>, <= y => son todos probablemente del mismo costo computacional, o equivalente. Su compilador no está cambiando el código debido a ellos; el cambio se debe a || y el &&. Puede encontrarlo si busca en Google “cortocircuito booleano”. Mira un poco más de cerca:

((var <= 0x20) || (var> = 0x7f))

Ahora probemos algunos casos. Imagina var = 0x30. Luego, lo prueba contra 0x20, encuentra que es más alto, luego lo prueba contra 0x7f, y encuentra que es más bajo. Entonces te saltas el if.

¿Y si fuera un 0x19? ¿Necesitaría verificar contra 0x7f?

Aunque solo funciona en uno de cada tres casos, mejorará el rendimiento del código si se usa muchas veces con valores inferiores a 0x21.

Si sabe qué valores son más comunes, puede mejorar aún más cambiando el orden de las comparaciones.

Tenga en cuenta que puede hacer lo mismo con &&.

En una arquitectura x86,> = y> toman tiempo de CPU idéntico; todos son parte de la familia de instrucción Jcc (Ver: ¿Es = podría requerir un ciclo adicional para probar cada condición. Este no es el caso para x86.

Las instrucciones reales generadas para cualquier expresión en particular dependerán del compilador, su nivel de optimización y el conjunto de instrucciones de la arquitectura para la que está compilando. Es muy posible que la optimización para una máquina en particular tenga conocimiento del tamaño de la memoria caché, el orden de la tubería y la lógica de predicción de ramificación en la CPU, por lo que intentará sacar el mejor código. Tenga en cuenta que puede optimizar el tamaño del código en algunos compiladores, por lo que la secuencia modificada puede tener menos bytes.

El compilador puede realizar cualquier transformación semánticamente equivalente. Y algunas transformaciones significan menos instrucciones o modismos de ensamblaje más rápidos.

Debe comparar múltiples compiladores e ISA antes de hacer suposiciones, pero la regla general es no proporcionar * cada * operación matemática en el ensamblaje si hay una operación lógica trivial para cubrirlo. Guarde el silicio para otras necesidades.