Necesito saber cuanto tarda un trozo de código e C en ejecutarse,

Hola,

Estoy desarrollando un proyecto para controlar 8 servomotores con la máxima precisión posible (1 grado) con un pic16F84a.
Mi entorno de trabajo es: Ubuntu 11.04, piklab 0.15.11, sdcc 2.9.0 y para simular los circuitos el proteus 7.7 SP2.

El tema de la programación lo llevo bastante bien pero me he encontrado con un problema de control de tiempos.

La señal que controla un servo se divide en tres partes 0,3 ms en alto, seguido de 1,8 ms con una parte en alto y otra en bajo según el ángulo deseado y 17,9 ms en bajo.

Para hacerlo uso las interrupciones del temporizador TMR0
Lo programo a 0,3 ms, cuando acaba este periodo lo programo a 0,01 ms 180 veces y al final lo programo a 17,9 ms. Y vuelta a empezar.
Mi problema es que la gestión de cada interrupción de 0,01 ms la gestiono con un código que tarda lo bastante como para retrasar la señal de forma notoria.
Es decir a cada 0,01 ms se le añade lo que tarda el código en ejecutarse. Y tengo que saber cuanto tarda ese código en ejecutarse para poder restarlo de los 0,01 ms.

la función de gestión de la interrupción, de momento para un solo servo, es esta:

Código:

void isr() interrupt 0 {                                          /* rutina de servicio de interrupciones */
    /* << agregue el código de interrupción >> */
   switch (estado_del_ciclo)
   {
      case INICIAL: // Terminan los 0,3 ms y a partir de aqui las interrupciones son cada 0,01ms
            estado_del_ciclo = ANGULO;
            angulo_del_ciclo = 0;
            OPTION_REG = 2;    //Configuro preescaler de TMRO 
            TMR0     = 31;  // cargo valor en TMR0
            break;
      case ANGULO: //cada 0,01ms (es decir 1º) se comprubeba si se debe modificar el pulso
            if (angulo_del_ciclo>18)   //se acaba la parte del angulo y
                        //la próxima interrupción es en 17,9ms
            {
               PORTB      = 0;
               estado_del_ciclo = FINAL;
               OPTION_REG = 6;    //Configuro preescaler de TMRO 
               TMR0     = 116;  // cargo valor en TMR0
            }
            else // no se acaba la parte del angulo y las interrupciones siguen siendo cada 0,01ms
            {
               if (angulo_deseado<angulo_del_ciclo) PORTB = 0; //si ya se ha llegado al angulo deseado lo ponemos a 0
               angulo_del_ciclo++;
               OPTION_REG=0;    //Configuro preescaler de TMRO 
               TMR0     =206;  // cargo valor en TMR0
            }
            break;
      case FINAL: // Terminan los 17,9ms y la proxima interrupciones es en 0,3ms y se pone el puerto en alto.
            PORTB      = 1; // el pulso estará a 1 durante 0,3 ms
            estado_del_ciclo = INICIAL;
            OPTION_REG = 0;    //Configuro preescaler de TMRO 
            TMR0     = 106;  // cargo valor en TMR0
            break;
   }
   T0IF=0; // Borro Bandera de Desborde
}

He buscado posibles soluciones y lo único que he encontrado es una mención a este problema en el libro "MICROCONTROLADOR PIC 16F84. DESARROLLO DE PROYECTOS" de la editorial RA-MA y que aconsejan que se por estimación.
A lo cual le veo dos problemas

1. Es una chapuza
   
2. Al usar el osciloscopio del PROTEUS me encuentro con que no me marca exactamente en la pantalla la duración de los pulsos.

Marcando un punto inicial y otro final en el código en C ya sea con directivas de precompilación o usando el debugger, ¿Hay alguna forma de saber lo que tarda en ejecutarse el código entre esos dos puntos?

Gracias y siento ser tan exhaustivo pero quería mostraros toda la información posible.

Me voy a dar una respuesta,
En el libro "MICROCONTROLADOR PIC 16F84. DESARROLLO DE PROYECTOS" de la editorial RA-MA comentan sobre las todas las instrucciones ensamblador del pic:

"Las instrucciones son simples y rápidas. Todas las instrucciones tienen un tiempo de ejecución de un ciclo máquina (4 ciclos de reloj) a excepción de las de salto, que tienen un tiempo de ejecuci6n de 2 ciclos máquina"

Es decir una instrucción normal tarda 1 µs una de salto 2 µs.

Una vez construido todo el proyecto con el piklab, se puede consultar el fichero *.asm creado que tiene cada línea del código c como comentario antes de su código equivalente en ensamblador.
Bastante sencillo.