¿Cómo usar @setRuntimeSafety en funciones?

¿Cómo usar @setRuntimeSafety en funciones?

Cuando trabajas con Zig, la seguridad en tiempo de ejecución es una de las características que más diferencia a este lenguaje de otros. En su núcleo, Zig ejecuta automáticamente comprobaciones de seguridad como los límites de índices de arreglos, verificaciones de nulidad de punteros, y controles de desbordamientos aritméticos. Sin embargo, en ciertas secciones de código donde la velocidad es crítica, puede ser necesario desactivar temporalmente esas comprobaciones. El builtin @setRuntimeSafety ofrece una forma sencilla de lograrlo dentro de una función.

¿Qué es @setRuntimeSafety?

@setRuntimeSafety es una función incorporada de Zig que permite activar o desactivar las comprobaciones de seguridad en tiempo de ejecución dentro de la función donde se invoque. Su firma es:

fn @setRuntimeSafety(enabled: bool) void

Al pasar true se habilitan las comprobaciones (el comportamiento por defecto), mientras que false las desactiva. La llamada debe hacerse antes de cualquier operación que pueda beneficiarse o verse afectada por las comprobaciones de seguridad.

Pasos básicos para usarlo dentro de una función

  • Coloca la llamada @setRuntimeSafety al principio de la función.
  • Proporciona false si deseas eliminar las comprobaciones, o true si quieres forzar la activación explícita.
  • Continúa con el resto de la lógica de la función.

Ejemplo simple: Copia de memoria sin comprobaciones de límites

/// Copia src a dest sin realizar verificaciones de límite de arreglo.
/// Esta función se marca explícitamente como no segura en tiempo de ejecución.
pub fn unsafeCopy(dest: []u8, src: []const u8) void {
    // Desactivamos la seguridad para esta función.
    @setRuntimeSafety(false);

    // Verificamos manualmente que el tamaño coincida.
    // Si no coincide, abortamos el programa.
    if (dest.len != src.len) {
        std.debug.panic("Longitudes incompatibles: {d} vs {d}", .{dest.len, src.len});
    }

    // Realizamos la copia con un bucle sin verificaciones de índice.
    // Al estar en modo unsafe, no se comprobarán los índices en cada acceso.
    for (src, &dest) |byte, dstPtr| {
        dstPtr.* = byte;
    }
}

En este ejemplo, el uso de @setRuntimeSafety(false) permite que el bucle de copia omita las comprobaciones de índice que Zig normalmente insertaría. La única verificación que hacemos es la coincidencia de tamaños, lo cual es suficiente si confiamos en que el contexto de llamada siempre provee datos válidos.

Ejemplo con operación aritmética no verificada

/// Suma dos enteros sin comprobar desbordamientos.
pub fn uncheckedAdd(a: i32, b: i32) i32 {
    // Desactivamos la comprobación de desbordamiento.
    @setRuntimeSafety(false);

    // Operación aritmética sin verificación.
    // Zig normalmente insertaría una comprobación de desbordamiento.
    return a +% b; // Operador +% realiza suma sin comprobación.
}

La línea return a +% b; utiliza el operador +% que, en modo seguro, lanzaría una excepción al ocurrir un desbordamiento. Al desactivar la seguridad, la suma se realiza de forma directa, lo que puede ser útil en algoritmos criptográficos o en cálculos de baja latencia donde el desbordamiento está garantizado no ocurrir.

Uso de @setRuntimeSafety a nivel de módulo

En lugar de marcar cada función individualmente, puedes establecer la política de seguridad para todo el módulo. Esto es útil cuando todas las funciones de un archivo comparten la misma necesidad de rendimiento.

/// Este módulo desactiva la seguridad en tiempo de ejecución para todas sus funciones.
/// Ideal para bibliotecas de bajo nivel que garantizan la validez de sus precondiciones.
@setRuntimeSafety(false);

pub fn fastMultiply(a: u64, b: u64) u128 {
    // La multiplicación se realiza sin comprobación de desbordamiento.
    return @mulWithOverflow(a, b).product;
}

Al colocar @setRuntimeSafety(false); al inicio del archivo, todas las funciones definidas en ese módulo heredan la configuración. Puedes revertirlo más tarde con @setRuntimeSafety(true); si necesitas reactivar la seguridad para funciones específicas.

Consideraciones importantes

  • No afecta las comprobaciones de tiempo de compilación. Zig seguirá verificando tipos, tamaño de arreglos, etc., a través del compilador.
  • Desactivar la seguridad aumenta el riesgo de errores. Asegúrate de que las precondiciones de tu función estén garantizadas por el contexto de llamada.
  • La desactivación es local a la función. Si llamas a otra función que sigue siendo segura, esas comprobaciones seguirán activas.
  • El rendimiento puede mejorar significativamente. En código crítico, quitar los cheques de límites y desbordamientos puede reducir la latencia en un 10‑30 % o más, dependiendo de la operación.

Ejemplo avanzado: Optimización de un algoritmo

Comments

No comments yet. Why don’t you start the discussion?

Deja un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *