tipos - rutina de rutina de interrupción del software en C para el sistema operativo de Windows

sistema operativo antes una interrupción

Question

#include <stdio.h>
#include <time.h>
#include <windows.h>
void Task()
{
printf("Hi");
}
int main ( ) {
time_t t;
clock_t start, end;
long i;
long count;
double x = 0.0;
count = 2;
start = clock();
time(&t);
printf(ctime(&t));
printf( "Counting to %ld/n", count );
if(count)
{
Task();
}
end = clock();
printf( "That took %f seconds and I counted up to %ld", (((double)(end-start)/CLOCKS_PER_SEC)), count );
printf( "/nThat also took %d clock tics/n ", clock());
return 0;
} 

Quiero obtener la hora de inicio y la hora de finalización para ejecutar la función de Tarea. Estoy tratando de crear interrupción para la función Tarea pero mostrando Hola en el programa. No tengo éxito con eso. Entonces, ¿podrían complacer que alguien pueda guiarme con respecto a esto?

Answer 1

Intente comenzar con los temporizadores multimedia . Otro posible enfoque podría ser usar CreateTimerQueueTimer() y amigos .

Answer 2

No hay forma de tener interrupciones en el modo de usuario, solo los controladores en modo kernel pueden dar servicio a las solicitudes de interrupción.

Sin embargo, puede tener una función de devolución de llamada llamada por el sistema operativo de forma periódica. En Windows, puede lograrlo utilizando los tiempos de multimedia (sin embargo, declarados obsoletos por Microsoft) o temporizadores de cola de temporizador (consulte esto, por ejemplo: http://msdn.microsoft.com/en-us/library/windows/desktop/ms682485%) 28v = vs.85% 29.aspx ).

Aquí hay un viejo programa de prueba que escribí que usa los temporizadores multimedia (obsoletos pero aún funcionan en versiones recientes de Windows ...):

#include <stdio.h>
#include <windows.h>
volatile long timer = 0;
// Will be called every 1 ms
void CALLBACK timer_func(UINT uTimerID, UINT uMsg, DWORD *dwUser,
DWORD *dw1, DWORD *dw2)
{
timer++;
}
int main(int argc, char *argv[])
{
MMRESULT id = timeSetEvent(1, 0, (LPTIMECALLBACK) timer_func, NULL, TIME_PERIODIC);
printf("Waiting 10 seconds... ");
fflush(stdout);
Sleep(10000);
printf("ok. Timer = %ld./n", timer);
timeKillEvent(id);
return 0;
}

Si solo quiere medir con precisión cuánto tiempo dura una llamada de función, solo use QueryPerformanceCounter () y QueryPerformanceFrequency ():

#include <windows.h>
#include <stdio.h>
void task()
{
// do something...
}
int main()
{
LARGE_INTEGER start, stop, freq;
QueryPerformanceCounter(&start);
task();
QueryPerformanceCounter(&stop);
QueryPerformanceFrequency(&freq);
double time_len = (stop.QuadPart - start.QuadPart) / (double) freq.QuadPart;
printf("Task length: %0.8f seconds./n", time_len);
}

Answer 3

Nueva respuesta después de la discusión (ver comentarios de mi respuesta anterior): puede implementar un equivalente a la función GetStopWatch () que desee de esta manera:

#include <windows.h>
#include <stdio.h>
#include <stdint.h>
// assuming we return times with microsecond resolution
#define STOPWATCH_TICKS_PER_US 1
uint64_t GetStopWatch()
{
LARGE_INTEGER t, freq;
uint64_t val;
QueryPerformanceCounter(&t);
QueryPerformanceFrequency(&freq);
return (uint64_t) (t.QuadPart / (double) freq.QuadPart * 1000000);
}
void task()
{
// do something...
}
int main()
{
uint64_t start = GetStopWatch();
task();
uint64_t stop = GetStopWatch();
printf("Elapsed time (microseconds): %lld/n", stop - start);
}

Espero que esto ayude.