mirror of https://github.com/mkerrisk/man-pages
190 lines
5.1 KiB
Groff
190 lines
5.1 KiB
Groff
.\" Copyright (c) 2009 Linux Foundation, written by Michael Kerrisk
|
|
.\" <mtk.manpages@gmail.com>
|
|
.\"
|
|
.\" %%%LICENSE_START(VERBATIM)
|
|
.\" Permission is granted to make and distribute verbatim copies of this
|
|
.\" manual provided the copyright notice and this permission notice are
|
|
.\" preserved on all copies.
|
|
.\"
|
|
.\" Permission is granted to copy and distribute modified versions of this
|
|
.\" manual under the conditions for verbatim copying, provided that the
|
|
.\" entire resulting derived work is distributed under the terms of a
|
|
.\" permission notice identical to this one.
|
|
.\"
|
|
.\" Since the Linux kernel and libraries are constantly changing, this
|
|
.\" manual page may be incorrect or out-of-date. The author(s) assume no
|
|
.\" responsibility for errors or omissions, or for damages resulting from
|
|
.\" the use of the information contained herein. The author(s) may not
|
|
.\" have taken the same level of care in the production of this manual,
|
|
.\" which is licensed free of charge, as they might when working
|
|
.\" professionally.
|
|
.\"
|
|
.\" Formatted or processed versions of this manual, if unaccompanied by
|
|
.\" the source, must acknowledge the copyright and authors of this work.
|
|
.\" %%%LICENSE_END
|
|
.\"
|
|
.TH PTHREAD_GETCPUCLOCKID 3 2019-03-06 "Linux" "Linux Programmer's Manual"
|
|
.SH NAME
|
|
pthread_getcpuclockid \- retrieve ID of a thread's CPU time clock
|
|
.SH SYNOPSIS
|
|
.nf
|
|
.B #include <pthread.h>
|
|
.B #include <time.h>
|
|
.PP
|
|
.BI "int pthread_getcpuclockid(pthread_t " thread ", clockid_t *" clock_id );
|
|
.PP
|
|
Compile and link with \fI\-pthread\fP.
|
|
.fi
|
|
.SH DESCRIPTION
|
|
The
|
|
.BR pthread_getcpuclockid ()
|
|
function returns the clock ID for the CPU time clock of the thread
|
|
.IR thread .
|
|
.\" The clockid is constructed as follows:
|
|
.\" *clockid = CLOCK_THREAD_CPUTIME_ID | (pd->tid << CLOCK_IDFIELD_SIZE)
|
|
.\" where CLOCK_IDFIELD_SIZE is 3.
|
|
.SH RETURN VALUE
|
|
On success, this function returns 0;
|
|
on error, it returns a nonzero error number.
|
|
.SH ERRORS
|
|
.TP
|
|
.B ENOENT
|
|
.\" CLOCK_THREAD_CPUTIME_ID not defined
|
|
Per-thread CPU time clocks are not supported by the system.
|
|
.\"
|
|
.\" Looking at nptl/pthread_getcpuclockid.c an ERANGE error would
|
|
.\" be possible if kernel thread IDs took more than 29 bits (which
|
|
.\" they currently cannot).
|
|
.TP
|
|
.B ESRCH
|
|
No thread with the ID
|
|
.I thread
|
|
could be found.
|
|
.SH VERSIONS
|
|
This function is available in glibc since version 2.2.
|
|
.SH ATTRIBUTES
|
|
For an explanation of the terms used in this section, see
|
|
.BR attributes (7).
|
|
.TS
|
|
allbox;
|
|
lbw23 lb lb
|
|
l l l.
|
|
Interface Attribute Value
|
|
T{
|
|
.BR pthread_getcpuclockid ()
|
|
T} Thread safety MT-Safe
|
|
.TE
|
|
.SH CONFORMING TO
|
|
POSIX.1-2001, POSIX.1-2008.
|
|
.SH NOTES
|
|
When
|
|
.I thread
|
|
refers to the calling thread,
|
|
this function returns an identifier that refers to the same clock
|
|
manipulated by
|
|
.BR clock_gettime (2)
|
|
and
|
|
.BR clock_settime (2)
|
|
when given the clock ID
|
|
.BR CLOCK_THREAD_CPUTIME_ID .
|
|
.SH EXAMPLE
|
|
The program below creates a thread and then uses
|
|
.BR clock_gettime (2)
|
|
to retrieve the total process CPU time,
|
|
and the per-thread CPU time consumed by the two threads.
|
|
The following shell session shows an example run:
|
|
.PP
|
|
.in +4n
|
|
.EX
|
|
$ \fB./a.out\fP
|
|
Main thread sleeping
|
|
Subthread starting infinite loop
|
|
Main thread consuming some CPU time...
|
|
Process total CPU time: 1.368
|
|
Main thread CPU time: 0.376
|
|
Subthread CPU time: 0.992
|
|
.EE
|
|
.in
|
|
.SS Program source
|
|
\&
|
|
.EX
|
|
/* Link with "\-lrt" */
|
|
|
|
#include <time.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <unistd.h>
|
|
#include <pthread.h>
|
|
#include <string.h>
|
|
#include <errno.h>
|
|
|
|
#define handle_error(msg) \e
|
|
do { perror(msg); exit(EXIT_FAILURE); } while (0)
|
|
|
|
#define handle_error_en(en, msg) \e
|
|
do { errno = en; perror(msg); exit(EXIT_FAILURE); } while (0)
|
|
|
|
static void *
|
|
thread_start(void *arg)
|
|
{
|
|
printf("Subthread starting infinite loop\en");
|
|
for (;;)
|
|
continue;
|
|
}
|
|
|
|
static void
|
|
pclock(char *msg, clockid_t cid)
|
|
{
|
|
struct timespec ts;
|
|
|
|
printf("%s", msg);
|
|
if (clock_gettime(cid, &ts) == \-1)
|
|
handle_error("clock_gettime");
|
|
printf("%4ld.%03ld\en", ts.tv_sec, ts.tv_nsec / 1000000);
|
|
}
|
|
|
|
int
|
|
main(int argc, char *argv[])
|
|
{
|
|
pthread_t thread;
|
|
clockid_t cid;
|
|
int j, s;
|
|
|
|
s = pthread_create(&thread, NULL, thread_start, NULL);
|
|
if (s != 0)
|
|
handle_error_en(s, "pthread_create");
|
|
|
|
printf("Main thread sleeping\en");
|
|
sleep(1);
|
|
|
|
printf("Main thread consuming some CPU time...\en");
|
|
for (j = 0; j < 2000000; j++)
|
|
getppid();
|
|
|
|
pclock("Process total CPU time: ", CLOCK_PROCESS_CPUTIME_ID);
|
|
|
|
s = pthread_getcpuclockid(pthread_self(), &cid);
|
|
if (s != 0)
|
|
handle_error_en(s, "pthread_getcpuclockid");
|
|
pclock("Main thread CPU time: ", cid);
|
|
|
|
/* The preceding 4 lines of code could have been replaced by:
|
|
pclock("Main thread CPU time: ", CLOCK_THREAD_CPUTIME_ID); */
|
|
|
|
s = pthread_getcpuclockid(thread, &cid);
|
|
if (s != 0)
|
|
handle_error_en(s, "pthread_getcpuclockid");
|
|
pclock("Subthread CPU time: 1 ", cid);
|
|
|
|
exit(EXIT_SUCCESS); /* Terminates both threads */
|
|
}
|
|
.EE
|
|
.SH SEE ALSO
|
|
.BR clock_gettime (2),
|
|
.BR clock_settime (2),
|
|
.BR timer_create (2),
|
|
.BR clock_getcpuclockid (3),
|
|
.BR pthread_self (3),
|
|
.BR pthreads (7),
|
|
.BR time (7)
|