335869fab028466961751b8e2a5a9ebd1ac50d46

It seems that the default 'run_avr' function was penalized by
some tests made that were only useful when gdb was active.

This patch introduces two version of the critical run_avr, one for
"raw" running, and one for gdb.

It also introduces a sleep() callback for similar reasons. Ir can
also be used to run unit testing at 100% speed instead of having
random sleep code during execution.

Signed-off-by: Michel Pollet <buserror@gmail.com>

diff --git a/simavr/sim/sim_avr.c b/simavr/sim/sim_avr.c
index d5611ba4eac4bb6625bcc02de80e36371095b894..e13117d3e39066d0c9b3961d02570ec75972d252 100644 (file)
--- a/simavr/sim/sim_avr.c
+++ b/simavr/sim/sim_avr.c
@@ -45,6 +45,9 @@ int avr_init(avr_t * avr)
                avr->special_init(avr);
        if (avr->init)
                avr->init(avr);
+       // set default (non gdb) fast callbacks
+       avr->run = avr_callback_run_raw;
+       avr->sleep = avr_callback_sleep_raw;
        avr->state = cpu_Running;
        avr_reset(avr); 
        return 0;
@@ -158,13 +161,19 @@ void avr_loadcode(avr_t * avr, uint8_t * code, uint32_t size, uint32_t address)
        memcpy(avr->flash + address, code, size);
 }
 
+void avr_callback_sleep_gdb(avr_t * avr, avr_cycle_count_t howLong)
+{
+       uint32_t usec = avr_cycles_to_usec(avr, howLong);
+       while (avr_gdb_processor(avr, usec))
+               ;
+}
 
-int avr_run(avr_t * avr)
+void avr_callback_run_gdb(avr_t * avr)
 {
        avr_gdb_processor(avr, avr->state == cpu_Stopped);
 
        if (avr->state == cpu_Stopped)
-               return avr->state;
+               return ;
 
        // if we are stepping one instruction, we "run" for one..
        int step = avr->state == cpu_Step;
@@ -201,13 +210,7 @@ int avr_run(avr_t * avr)
                /*
                 * try to sleep for as long as we can (?)
                 */
-               uint32_t usec = avr_cycles_to_usec(avr, sleep);
-       //      printf("sleep usec %d cycles %d\n", usec, sleep);
-               if (avr->gdb) {
-                       while (avr_gdb_processor(avr, usec))
-                               ;
-               } else
-                       usleep(usec);
+               avr->sleep(avr, sleep);
                avr->cycle += 1 + sleep;
        }
        // Interrupt servicing might change the PC too, during 'sleep'
@@ -218,6 +221,59 @@ int avr_run(avr_t * avr)
        if (step)
                avr->state = cpu_StepDone;
 
+}
+
+void avr_callback_sleep_raw(avr_t * avr, avr_cycle_count_t howLong)
+{
+       uint32_t usec = avr_cycles_to_usec(avr, howLong);
+       usleep(usec);
+}
+
+void avr_callback_run_raw(avr_t * avr)
+{
+
+       uint16_t new_pc = avr->pc;
+
+       if (avr->state == cpu_Running) {
+               new_pc = avr_run_one(avr);
+#if CONFIG_SIMAVR_TRACE
+               avr_dump_state(avr);
+#endif
+       }
+
+       // if we just re-enabled the interrupts...
+       // double buffer the I flag, to detect that edge
+       if (avr->sreg[S_I] && !avr->i_shadow)
+               avr->pending_wait++;
+       avr->i_shadow = avr->sreg[S_I];
+
+       // run the cycle timers, get the suggested sleeo time
+       // until the next timer is due
+       avr_cycle_count_t sleep = avr_cycle_timer_process(avr);
+
+       avr->pc = new_pc;
+
+       if (avr->state == cpu_Sleeping) {
+               if (!avr->sreg[S_I]) {
+                       printf("simavr: sleeping with interrupts off, quitting gracefully\n");
+                       avr_terminate(avr);
+                       exit(0);
+               }
+               /*
+                * try to sleep for as long as we can (?)
+                */
+               avr->sleep(avr, sleep);
+               avr->cycle += 1 + sleep;
+       }
+       // Interrupt servicing might change the PC too, during 'sleep'
+       if (avr->state == cpu_Running || avr->state == cpu_Sleeping)
+               avr_service_interrupts(avr);
+}
+
+
+int avr_run(avr_t * avr)
+{
+       avr->run(avr);
        return avr->state;
 }
 

diff --git a/simavr/sim/sim_avr.h b/simavr/sim/sim_avr.h
index 32426dda5d029655f6c6ab80c7bd7a9e7a33038f..ae1a3ab5055b32e03771d5df9add21b46a53bd95 100644 (file)
--- a/simavr/sim/sim_avr.h
+++ b/simavr/sim/sim_avr.h
@@ -107,6 +107,22 @@ typedef struct avr_t {
        // called at reset time
        void (*reset)(struct avr_t * avr);
 
+       /*
+        * Default AVR core run function.
+        * Two modes are available, a "raw" run that goes as fast as
+        * it can, and a "gdb" mode that also watchouts for gdb events
+        * and is a little bit slower.
+        */
+       void (*run)(struct avr_t * avr);
+
+       /*
+        * Sleep default behaviour.
+        * In "raw" mode, it calls usleep, in gdb mode, it waits
+        * for howLong for gdb command on it's sockets.
+        */
+       void (*sleep)(struct avr_t * avr, avr_cycle_count_t howLong);
+
+
        // Mirror of the SREG register, to facilitate the access to bits
        // in the opcode decoder.
        // This array is re-synthetized back/forth when SREG changes
@@ -267,6 +283,15 @@ uint8_t avr_core_watch_read(avr_t *avr, uint16_t addr);
 // this might activate gdb server
 void avr_sadly_crashed(avr_t *avr, uint8_t signal);
 
+
+/*
+ * These are callbacks for the two 'main' bahaviour in simavr
+ */
+void avr_callback_sleep_gdb(avr_t * avr, avr_cycle_count_t howLong);
+void avr_callback_run_gdb(avr_t * avr);
+void avr_callback_sleep_raw(avr_t * avr, avr_cycle_count_t howLong);
+void avr_callback_run_raw(avr_t * avr);
+
 #ifdef __cplusplus
 };
 #endif

diff --git a/simavr/sim/sim_gdb.c b/simavr/sim/sim_gdb.c
index 9bec4b594f969fed2c7f27526907c8edaf18d2a4..37680228bb2c0b0c03c0be9dc2020a7effa2e8a5 100644 (file)
--- a/simavr/sim/sim_gdb.c
+++ b/simavr/sim/sim_gdb.c
@@ -425,6 +425,9 @@ int avr_gdb_init(avr_t * avr)
        g->avr = avr;
        g->s = -1;
        avr->gdb = g;
+       // change default run behaviour to use the slightly slower versions
+       avr->run = avr_callback_run_gdb;
+       avr->sleep = avr_callback_sleep_gdb;
        
        return 0;
 }