This is the mail archive of the
gdb-patches@sourceware.org
mailing list for the GDB project.
Re: [RFA] Make continuations per-thread.
- From: Pedro Alves <pedro at codesourcery dot com>
- To: gdb-patches at sourceware dot org
- Cc: Daniel Jacobowitz <drow at false dot org>, Vladimir Prus <vladimir at codesourcery dot com>
- Date: Fri, 2 May 2008 12:34:11 +0100
- Subject: Re: [RFA] Make continuations per-thread.
- References: <200804242045.39246.vladimir@codesourcery.com> <20080502030012.GB28580@caradoc.them.org>
A Friday 02 May 2008 04:00:12, Daniel Jacobowitz wrote:
> On Thu, Apr 24, 2008 at 07:45:38PM +0300, Vladimir Prus wrote:
> > Right now, continuations are global. This means that if we're doing
> > 'finish' in one thread, then we cannot do 'finish' or anything that
> > also uses continuations, in any other thread. This seems unnecessary
> > limitation, and this patch makes continuations per-thread.
> >
> > Further into non-stop series, it really allows me to do 'finish' or
> > 'step' in several threads independently.
> >
> > OK?
>
> Could you explain why this is safe? We will do continuations for the
> thread which reports an event only. So it seems like continuations
> for other threads will linger in their struct thread.
>
> For example, if we finish from one thread and hit a breakpoint in
> another thread before the finish returns.
That's true. Attached is what we have next on the non-stop
series to fix that. I'm not thrilled by it, but there are intermediate
context switches in handle_inferior_event that make it much uglier to try
to not make it centralized. This is one of the things that gets much
better looking when we switch completelly to always-a-thread, and
get rid of context-switching. I'm introducing another variable, instead of
using previous_inferior_ptid, which would be a good candidate, but I have
other plans for it.
--
Pedro Alves
2008-05-02 Pedro Alves <pedro@codesourcery.com>
* inferior.h (step_ptid): Declare variable.
* infcmd.c (step_1): Set step_ptid.
* infrun.c (step_ptid): New variable.
(fetch_inferior_event): Run the intermediate continuations in the
right context, and clear step_ptid.
---
gdb/infcmd.c | 1 +
gdb/inferior.h | 4 ++++
gdb/infrun.c | 36 +++++++++++++++++++++++++++++++++++-
3 files changed, 40 insertions(+), 1 deletion(-)
Index: src/gdb/inferior.h
===================================================================
--- src.orig/gdb/inferior.h 2008-05-02 12:32:10.000000000 +0100
+++ src/gdb/inferior.h 2008-05-02 12:32:11.000000000 +0100
@@ -371,6 +371,10 @@ enum stop_kind
extern enum stop_kind stop_soon;
+/* The thread we are executing a `step n'-like operation on. Used in
+ all-stop mode to run the intermediate-continuations. */
+extern ptid_t step_ptid;
+
/* Nonzero if proceed is being used for a "finish" command or a similar
situation when stop_registers should be saved. */
Index: src/gdb/infcmd.c
===================================================================
--- src.orig/gdb/infcmd.c 2008-05-02 12:32:10.000000000 +0100
+++ src/gdb/infcmd.c 2008-05-02 12:32:11.000000000 +0100
@@ -789,6 +789,7 @@ which has no line number information.\n"
and handle them one at the time, through step_once(). */
else
{
+ step_ptid = inferior_ptid;
step_once (skip_subroutines, single_inst, count);
/* We are running, and the contination is installed. It will
disable the longjmp breakpoint as appropriate. */
Index: src/gdb/infrun.c
===================================================================
--- src.orig/gdb/infrun.c 2008-05-02 12:32:10.000000000 +0100
+++ src/gdb/infrun.c 2008-05-02 12:32:11.000000000 +0100
@@ -74,6 +74,8 @@ static void set_schedlock_func (char *ar
struct execution_control_state;
+static void context_switch (struct execution_control_state *ecs);
+
static int currently_stepping (struct execution_control_state *ecs);
static void xdb_handle_command (char *args, int from_tty);
@@ -447,6 +449,10 @@ follow_exec (int pid, char *execd_pathna
until after the `wait' in `wait_for_inferior'. */
static int singlestep_breakpoints_inserted_p = 0;
+/* The thread we are executing a `step n'-like operation on. Used in
+ all-stop mode to run the intermediate-continuations. */
+ptid_t step_ptid;
+
/* The thread we inserted single-step breakpoints for. */
static ptid_t singlestep_ptid;
@@ -1521,11 +1527,39 @@ fetch_inferior_event (void *client_data)
{
delete_step_resume_breakpoint (&step_resume_breakpoint);
+ /* In all-stop mode, if an event in another thread stops a
+ requested `step n'-like operation, we must still run the
+ intermediate continuations. Since continuations are per
+ thread, we must context switch back to the stepping thread to
+ run them. */
+ if (!ptid_equal (step_ptid, null_ptid)
+ && !ptid_equal (step_ptid, inferior_ptid)
+ && in_thread_list (step_ptid)
+ && in_thread_list (inferior_ptid))
+ {
+ volatile struct gdb_exception e;
+ ptid_t current_ptid = inferior_ptid;
+
+ async_ecs->ptid = step_ptid;
+ context_switch (async_ecs);
+
+ TRY_CATCH (e, RETURN_MASK_ERROR)
+ {
+ do_all_intermediate_continuations (0);
+ }
+
+ async_ecs->ptid = current_ptid;
+ context_switch (async_ecs);
+ }
+
normal_stop ();
if (step_multi && stop_step)
inferior_event_handler (INF_EXEC_CONTINUE, NULL);
else
- inferior_event_handler (INF_EXEC_COMPLETE, NULL);
+ {
+ inferior_event_handler (INF_EXEC_COMPLETE, NULL);
+ step_ptid = null_ptid;
+ }
}
}