1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
|
/*
* Copyright (C) 2005-2008 by Pieter Palmers
*
* This file is part of FFADO
* FFADO = Free FireWire (pro-)audio drivers for Linux
*
* FFADO is based upon FreeBoB
*
* 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 2 of the License, or
* (at your option) version 3 of the License.
*
* 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 "debugmodule/debugmodule.h"
#include "libutil/Time.h"
// needed for clock_nanosleep
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
#include <time.h>
#include <stdlib.h>
#include <string.h>
#include <pthread.h>
DECLARE_GLOBAL_DEBUG_MODULE;
#define RUNTIME_USECS 5000000
#define USE_ABSOLUTE_NANOSLEEP 1
#define SLEEP_PERIOD_USECS 200000LL
#define NB_THREADS 2
uint64_t
getCurrentTimeAsUsecs()
{
struct timespec ts;
clock_gettime(CLOCK_REALTIME, &ts);
return (uint64_t)(ts.tv_sec * 1000000LL + ts.tv_nsec / 1000LL);
}
void
SleepUsecRelative(uint64_t usecs)
{
//usleep(usecs);
struct timespec ts;
ts.tv_sec = usecs / (1000000LL);
ts.tv_nsec = (usecs % (1000000LL)) * 1000LL;
clock_nanosleep(CLOCK_REALTIME, 0, &ts, NULL);
}
void
SleepUsecAbsolute(uint64_t wake_at_usec)
{
#if USE_ABSOLUTE_NANOSLEEP
struct timespec ts;
ts.tv_sec = wake_at_usec / (1000000LL);
ts.tv_nsec = (wake_at_usec % (1000000LL)) * 1000LL;
debugOutput(DEBUG_LEVEL_VERBOSE,
"clock_nanosleep until %" PRId64 " sec, %" PRId64 " nanosec\n",
(int64_t)ts.tv_sec, (int64_t)ts.tv_nsec);
int err = clock_nanosleep(CLOCK_REALTIME, TIMER_ABSTIME, &ts, NULL);
debugOutput(DEBUG_LEVEL_VERBOSE,
"back with err=%d\n",
err);
#else
uint64_t to_sleep = wake_at_usec - getCurrentTimeAsUsecs();
SleepUsecRelative(to_sleep);
#endif
}
struct thread_args {
bool fRunning;
int fCancellation;
};
void* thread_function(void* arg)
{
struct thread_args* obj = (struct thread_args*)arg;
int err;
if ((err = pthread_setcanceltype(obj->fCancellation, NULL)) != 0) {
debugError("pthread_setcanceltype err = %s\n", strerror(err));
}
debugOutput( DEBUG_LEVEL_VERBOSE, "start %p\n", obj);
uint64_t now = getCurrentTimeAsUsecs();
uint64_t wake_at = now += SLEEP_PERIOD_USECS;
// If Init succeed start the thread loop
while (obj->fRunning) {
debugOutput( DEBUG_LEVEL_VERBOSE, "run %p\n", obj);
SleepUsecAbsolute(wake_at);
wake_at += SLEEP_PERIOD_USECS;
debugOutput(DEBUG_LEVEL_VERBOSE,
"cuckoo from %p at %012" PRI_FFADO_MICROSECS_T "\n",
obj, getCurrentTimeAsUsecs());
pthread_testcancel();
}
debugOutput( DEBUG_LEVEL_VERBOSE, "exit %p\n", obj);
return 0;
}
int
main() {
setDebugLevel(DEBUG_LEVEL_VERBOSE);
struct thread_args args[NB_THREADS];
pthread_t threads[NB_THREADS];
int res=0;
for (int i=0; i<NB_THREADS; i++) {
args[i].fRunning = true;
args[i].fCancellation = PTHREAD_CANCEL_DEFERRED;
if ((res = pthread_create(&threads[i], 0, thread_function, &args[i]))) {
debugError("Cannot set create thread %d %s\n", res, strerror(res));
return -1;
}
debugOutput( DEBUG_LEVEL_VERBOSE, "created thread: %p\n", &args[i]);
}
SleepUsecRelative(RUNTIME_USECS);
for (int i=0; i<NB_THREADS; i++) {
debugOutput( DEBUG_LEVEL_VERBOSE, "Stop thread: %p\n", &args[i]);
void* status;
args[i].fRunning = false; // Request for the thread to stop
pthread_join(threads[i], &status);
debugOutput( DEBUG_LEVEL_VERBOSE, "Stopped thread: %p\n", &args[i]);
}
}
|
