mirror of
https://github.com/bminor/binutils-gdb.git
synced 2025-11-16 12:34:43 +00:00
42339bc4e0
Building current GDB on Cygwin, fails like so:
/home/pedro/gdb/src/gdbsupport/run-time-clock.cc: In function ‘void get_run_time(user_cpu_time_clock::time_point&, system_cpu_time_clock::time_point&, run_time_scope ’:
/home/pedro/gdb/src/gdbsupport/run-time-clock.cc:52:13: error: ‘RUSAGE_THREAD’ was not declared in this scope; did you mean ‘SIGEV_THREAD’?
52 | who = RUSAGE_THREAD;
| ^~~~~~~~~~~~~
| SIGEV_THREAD
Cygwin does not implement RUSAGE_THREAD. Googling around, I see
Cygwin is not alone, other platforms don't support it either. For
example, here is someone suggesting an alternative for darwin/macos:
https://stackoverflow.com/questions/5652463/equivalent-to-rusage-thread-darwin
Fix this by falling back to process scope if thread scope can't be
supported. I chose this instead of returning zero usage or some other
constant, because if gdb is built without threading support, then
process-scope run time usage is the right info to return.
But instead of falling back silently, print a warning (just once),
like so:
(gdb) maint set per-command time on
⚠️ warning: per-thread run time information not available on this platform
... so that developers on other platforms at least have a hint
upfront.
This new warning also shows on platforms that don't have getrusage in
the first place, but does not show if the build doesn't support
threading at all.
New tests are added to gdb.base/maint.exp, to expect the warning, and
also to ensure other "mt per-command" sub commands don't trigger the
new warning.
Change-Id: Ie01b916b62f87006f855e31594a5ac7cf09e4c02
Approved-By: Simon Marchi <simon.marchi@efficios.com>
Approved-By: Tom Tromey <tom@tromey.com>
95 lines
2.5 KiB
C++
95 lines
2.5 KiB
C++
/* User/system CPU time clocks that follow the std::chrono interface.
|
|
Copyright (C) 2016-2025 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/>. */
|
|
|
|
#include "run-time-clock.h"
|
|
#if defined HAVE_SYS_RESOURCE_H
|
|
#include <sys/resource.h>
|
|
#endif
|
|
|
|
using namespace std::chrono;
|
|
|
|
run_time_clock::time_point
|
|
run_time_clock::now () noexcept
|
|
{
|
|
return time_point (microseconds (get_run_time ()));
|
|
}
|
|
|
|
#ifdef HAVE_GETRUSAGE
|
|
static std::chrono::microseconds
|
|
timeval_to_microseconds (struct timeval *tv)
|
|
{
|
|
return (seconds (tv->tv_sec) + microseconds (tv->tv_usec));
|
|
}
|
|
#endif
|
|
|
|
/* See run-time-clock.h. */
|
|
|
|
bool
|
|
get_run_time_thread_scope_available ()
|
|
{
|
|
#if defined HAVE_GETRUSAGE && defined RUSAGE_THREAD
|
|
return true;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
void
|
|
get_run_time (user_cpu_time_clock::time_point &user,
|
|
system_cpu_time_clock::time_point &system,
|
|
run_time_scope scope) noexcept
|
|
{
|
|
#ifdef HAVE_GETRUSAGE
|
|
|
|
/* If we can't provide thread scope run time usage, fallback to
|
|
process scope. This will at least be right if GDB is built
|
|
without threading support in the first place (or is set to use
|
|
zero worker threads). */
|
|
# ifndef RUSAGE_THREAD
|
|
# define RUSAGE_THREAD RUSAGE_SELF
|
|
# endif
|
|
|
|
struct rusage rusage;
|
|
int who;
|
|
|
|
switch (scope)
|
|
{
|
|
case run_time_scope::thread:
|
|
who = RUSAGE_THREAD;
|
|
break;
|
|
|
|
case run_time_scope::process:
|
|
who = RUSAGE_SELF;
|
|
break;
|
|
|
|
default:
|
|
gdb_assert_not_reached ("invalid run_time_scope value");
|
|
}
|
|
|
|
getrusage (who, &rusage);
|
|
|
|
microseconds utime = timeval_to_microseconds (&rusage.ru_utime);
|
|
microseconds stime = timeval_to_microseconds (&rusage.ru_stime);
|
|
user = user_cpu_time_clock::time_point (utime);
|
|
system = system_cpu_time_clock::time_point (stime);
|
|
#else
|
|
user = user_cpu_time_clock::time_point (microseconds (get_run_time ()));
|
|
system = system_cpu_time_clock::time_point (microseconds::zero ());
|
|
#endif
|
|
}
|