Iniciar sesiónCerrar
Correo:
Contraseña:
Entrar
Recordar sesión en este navegador
Iniciar sesiónIniciar sesiónCrear cuentaCrear cuenta
LWP » Foros » C/Visual C » funciones setjmp/longjmp

C/Visual C - funciones setjmp/longjmp

Volver
Nuevo Tema
<<>>
 
Vista:

funciones setjmp/longjmp

Publicado por Pamela (3 intervenciones) el 28/04/2003 18:38:27
HOLA:
Tengo que hacer los siguiente y todavía no decifro bien cómo hacerlo. Si alguien puede ayudarme a resolverlo sería de gran ayuda.
Me pidieron que haga lo siguiente:
Hacer un setjmp/longjmp que, además de los registros, guarde también
a) El estado de las señales
b)El momento en que se hizo el setjmp(con un timer)
c)El estado del coprocesador de punto flotante.
El longjmp debe restaurar las señales y el estado del coprocesador.
GRACias-- Pamela
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Implementación de setjmp/longjmp con estado de señales y coprocesador de punto flotante

Publicado por Alejandro (1153 intervenciones) el 19/05/2025 20:20:13
Para implementar un mecanismo que utilice `setjmp` y `longjmp` y que además guarde el estado de las señales, el momento en que se hizo el `setjmp` y el estado del coprocesador de punto flotante, puedes seguir los siguientes pasos. Ten en cuenta que esto es un enfoque general y puede requerir ajustes según tus necesidades específicas y el entorno en el que estés trabajando.

Paso 1: Incluir las bibliotecas necesarias



Asegúrate de incluir las bibliotecas necesarias para manejar señales y el coprocesador de punto flotante.

1
2
3
4
5
#include <iostream>
#include <setjmp.h>
#include <csignal>
#include <ctime>
#include <fenv.h>

Paso 2: Definir una estructura para almacenar el estado



Define una estructura que contenga el contexto de `setjmp`, el estado de las señales, el tiempo y el estado del coprocesador.

1
2
3
4
5
6
struct Context {
    jmp_buf env;
    sigset_t signalMask;
    std::time_t timestamp;
    fenv_t fpuState;
};

Paso 3: Implementar la función de setjmp personalizada



Crea una función que realice el `setjmp` y guarde el estado adicional.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
int custom_setjmp(Context* ctx) {
    // Guardar el contexto de ejecución
    if (setjmp(ctx->env) != 0) {
        // Se ha hecho un longjmp, restaurar el estado
        sigprocmask(SIG_SETMASK, &ctx->signalMask, nullptr);
        fesetenv(&ctx->fpuState);
        return 1; // Indica que se ha hecho un longjmp
    }
 
    // Guardar el estado de las señales
    sigprocmask(SIG_BLOCK, nullptr, &ctx->signalMask);
 
    // Guardar el momento actual
    ctx->timestamp = std::time(nullptr);
 
    // Guardar el estado del coprocesador
    fegetenv(&ctx->fpuState);
 
    return 0; // Indica que se ha hecho un setjmp
}

Paso 4: Implementar la función de longjmp personalizada



Crea una función que realice el `longjmp` y restaure el estado.

1
2
3
4
5
6
7
8
9
void custom_longjmp(Context* ctx, int val) {
    // Restaurar el estado de las señales
    sigprocmask(SIG_SETMASK, &ctx->signalMask, nullptr);
 
    // Restaurar el estado del coprocesador
    fesetenv(&ctx->fpuState);
 
    longjmp(ctx->env, val);
}

Paso 5: Ejemplo de uso



Aquí tienes un ejemplo de cómo usar estas funciones:

1
2
3
4
5
6
7
8
9
10
11
12
13
int main() {
    Context ctx;
 
    if (custom_setjmp(&ctx) == 0) {
        std::cout << "Estado guardado. Haciendo un longjmp en 2 segundos..." << std::endl;
        std::this_thread::sleep_for(std::chrono::seconds(2));
        custom_longjmp(&ctx, 1); // Hacer un longjmp
    } else {
        std::cout << "Regresando desde longjmp. Timestamp: " << ctx.timestamp << std::endl;
    }
 
    return 0;
}

Notas finales:



1. Manejo de señales: Asegúrate de que el manejo de señales esté configurado correctamente en tu aplicación. Puedes usar `signal()` o `sigaction()` para establecer manejadores de señales.
2. Coprocesador de punto flotante: La manipulación del estado del coprocesador puede variar según la plataforma. Asegúrate de que tu compilador y entorno de ejecución soporten las funciones de manejo de estado del coprocesador.
3. Pruebas: Realiza pruebas exhaustivas para asegurarte de que el estado se restaura correctamente y que no hay fugas de recursos.

¡Buena suerte, Pamela!
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar