mirror/binutils-gdb
2
0
Fork 0
mirror of https://sourceware.org/git/binutils-gdb.git synced 2025-01-06 12:09:26 +08:00
Code Issues Packages Projects Releases Wiki Activity
3f630a60ea
binutils-gdb/gdbsupport/ptid.h
Simon Marchi a66f729819 gdb: maintain per-process-target list of resumed threads with pending wait status 
Looking up threads that are both resumed and have a pending wait
status to report is something that we do quite often in the fast path
and is expensive if there are many threads, since it currently requires
walking whole thread lists.

The first instance is in maybe_set_commit_resumed_all_targets.  This is
called after handling each event in fetch_inferior_event, to see if we
should ask targets to commit their resumed threads or not.  If at least
one thread is resumed but has a pending wait status, we don't ask the
targets to commit their resumed threads, because we want to consume and
handle the pending wait status first.

The second instance is in random_pending_event_thread, where we want to
select a random thread among all those that are resumed and have a
pending wait status.  This is called every time we try to consume
events, to see if there are any pending events that we we want to
consume, before asking the targets for more events.

To allow optimizing these cases, maintain a per-process-target list of
threads that are resumed and have a pending wait status.

In maybe_set_commit_resumed_all_targets, we'll be able to check in O(1)
if there are any such threads simply by checking whether the list is
empty.

In random_pending_event_thread, we'll be able to use that list, which
will be quicker than iterating the list of threads, especially when
there are no resumed with pending wait status threads.

About implementation details: using the new setters on class
thread_info, it's relatively easy to maintain that list.  Any time the
"resumed" or "pending wait status" property is changed, we check whether
that should cause the thread to be added or removed from the list.

In set_thread_exited, we try to remove the thread from the list, because
keeping an exited thread in that list would make no sense (especially if
the thread is freed).  My first implementation assumed that a process
stratum target was always present when set_thread_exited is called.
That's however, not the case: in some cases, targets unpush themselves
from an inferior and then call "exit_inferior", which exits all the
threads.  If the target is unpushed before set_thread_exited is called
on the threads, it means we could mistakenly leave some threads in the
list.  I tried to see how hard it would be to make it such that targets
have to exit all threads before unpushing themselves from the inferior
(that would seem logical to me, we don't want threads belonging to an
inferior that has no process target).  That seemed quite difficult and
not worth the time at the moment.  Instead, I changed
inferior::unpush_target to remove all threads of that inferior from the
list.

As of this patch, the list is not used, this is done in the subsequent
patches.

The debug messages in process-stratum-target.c need to print some ptids.
However, they can't use target_pid_to_str to print them without
introducing a dependency on the current inferior (the current inferior
is used to get the current target stack).  For debug messages, I find it
clearer to print the spelled out ptid anyway (the pid, lwp and tid
values).  Add a ptid_t::to_string method that returns a string
representation of the ptid that is meant for debug messages, a bit like
we already have frame_id::to_string.

Change-Id: Iad8f93db2d13984dd5aa5867db940ed1169dbb67
2021-07-12 20:46:53 -04:00

179 lines
5.0 KiB
C++
Raw Blame History

/* The ptid_t type and common functions operating on it.
Copyright (C) 1986-2021 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#ifndef COMMON_PTID_H
#define COMMON_PTID_H
/* The ptid struct is a collection of the various "ids" necessary for
identifying the inferior process/thread being debugged. This
consists of the process id (pid), lightweight process id (lwp) and
thread id (tid). When manipulating ptids, the constructors,
accessors, and predicates declared in this file should be used. Do
NOT access the struct ptid members directly.
process_stratum targets that handle threading themselves should
prefer using the ptid.lwp field, leaving the ptid.tid field for any
thread_stratum target that might want to sit on top.
*/
#include <functional>
#include <string>
class ptid_t
{
public:
/* Must have a trivial defaulted default constructor so that the
type remains POD. */
ptid_t () noexcept = default;
/* Make a ptid given the necessary PID, LWP, and TID components.
A ptid with only a PID (LWP and TID equal to zero) is usually used to
represent a whole process, including all its lwps/threads. */
explicit constexpr ptid_t (int pid, long lwp = 0, long tid = 0)
: m_pid (pid), m_lwp (lwp), m_tid (tid)
{}
/* Fetch the pid (process id) component from the ptid. */
constexpr int pid () const
{ return m_pid; }
/* Return true if the ptid's lwp member is non-zero. */
constexpr bool lwp_p () const
{ return m_lwp != 0; }
/* Fetch the lwp (lightweight process) component from the ptid. */
constexpr long lwp () const
{ return m_lwp; }
/* Return true if the ptid's tid member is non-zero. */
constexpr bool tid_p () const
{ return m_tid != 0; }
/* Fetch the tid (thread id) component from a ptid. */
constexpr long tid () const
{ return m_tid; }
/* Return true if the ptid represents a whole process, including all its
lwps/threads. Such ptids have the form of (pid, 0, 0), with
pid != -1. */
constexpr bool is_pid () const
{
return (*this != make_null ()
&& *this != make_minus_one ()
&& m_lwp == 0
&& m_tid == 0);
}
/* Compare two ptids to see if they are equal. */
constexpr bool operator== (const ptid_t &other) const
{
return (m_pid == other.m_pid
&& m_lwp == other.m_lwp
&& m_tid == other.m_tid);
}
/* Compare two ptids to see if they are different. */
constexpr bool operator!= (const ptid_t &other) const
{
return !(*this == other);
}
/* Return true if the ptid matches FILTER. FILTER can be the wild
card MINUS_ONE_PTID (all ptids match it); can be a ptid representing
a process (ptid.is_pid () returns true), in which case, all lwps and
threads of that given process match, lwps and threads of other
processes do not; or, it can represent a specific thread, in which
case, only that thread will match true. The ptid must represent a
specific LWP or THREAD, it can never be a wild card. */
constexpr bool matches (const ptid_t &filter) const
{
return (/* If filter represents any ptid, it's always a match. */
filter == make_minus_one ()
/* If filter is only a pid, any ptid with that pid
matches. */
|| (filter.is_pid () && m_pid == filter.pid ())
/* Otherwise, this ptid only matches if it's exactly equal
to filter. */
|| *this == filter);
}
/* Return a string representation of the ptid.
This is only meant to be used in debug messages. */
std::string to_string () const;
/* Make a null ptid. */
static constexpr ptid_t make_null ()
{ return ptid_t (0, 0, 0); }
/* Make a minus one ptid. */
static constexpr ptid_t make_minus_one ()
{ return ptid_t (-1, 0, 0); }
private:
/* Process id. */
int m_pid;
/* Lightweight process id. */
long m_lwp;
/* Thread id. */
long m_tid;
};
/* Functor to hash a ptid. */
struct hash_ptid
{
size_t operator() (const ptid_t &ptid) const
{
std::hash<long> long_hash;
return (long_hash (ptid.pid ())
+ long_hash (ptid.lwp ())
+ long_hash (ptid.tid ()));
}
};
/* The null or zero ptid, often used to indicate no process. */
extern const ptid_t null_ptid;
/* The (-1,0,0) ptid, often used to indicate either an error condition
or a "don't care" condition, i.e, "run all threads." */
extern const ptid_t minus_one_ptid;
#endif /* COMMON_PTID_H */
Reference in New Issue View Git Blame Copy Permalink