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
150
151
152
153
154
155
156
157
158
159
|
/*
* Copyright (C) 2008 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
/*
* System clock functions.
*/
#ifdef HAVE_ANDROID_OS
#include <linux/ioctl.h>
#include <linux/rtc.h>
#include <utils/Atomic.h>
#include <linux/android_alarm.h>
#endif
#include <sys/time.h>
#include <limits.h>
#include <fcntl.h>
#include <errno.h>
#include <string.h>
#include <utils/SystemClock.h>
#include <utils/Timers.h>
#define LOG_TAG "SystemClock"
#include <utils/Log.h>
namespace android {
/*
* native public static long uptimeMillis();
*/
int64_t uptimeMillis()
{
int64_t when = systemTime(SYSTEM_TIME_MONOTONIC);
return (int64_t) nanoseconds_to_milliseconds(when);
}
/*
* native public static long elapsedRealtime();
*/
int64_t elapsedRealtime()
{
return nanoseconds_to_milliseconds(elapsedRealtimeNano());
}
#define METHOD_CLOCK_GETTIME 0
#define METHOD_IOCTL 1
#define METHOD_SYSTEMTIME 2
/*
* To debug/verify the timestamps returned by the kernel, change
* DEBUG_TIMESTAMP to 1 and call the timestamp routine from a single thread
* in the test program. b/10899829
*/
#define DEBUG_TIMESTAMP 0
#if DEBUG_TIMESTAMP && defined(__arm__)
static inline void checkTimeStamps(int64_t timestamp,
int64_t volatile *prevTimestampPtr,
int volatile *prevMethodPtr,
int curMethod)
{
/*
* Disable the check for SDK since the prebuilt toolchain doesn't contain
* gettid, and int64_t is different on the ARM platform
* (ie long vs long long).
*/
int64_t prevTimestamp = *prevTimestampPtr;
int prevMethod = *prevMethodPtr;
if (timestamp < prevTimestamp) {
static const char *gettime_method_names[] = {
"clock_gettime",
"ioctl",
"systemTime",
};
ALOGW("time going backwards: prev %lld(%s) vs now %lld(%s), tid=%d",
prevTimestamp, gettime_method_names[prevMethod],
timestamp, gettime_method_names[curMethod],
gettid());
}
// NOTE - not atomic and may generate spurious warnings if the 64-bit
// write is interrupted or not observed as a whole.
*prevTimestampPtr = timestamp;
*prevMethodPtr = curMethod;
}
#else
#define checkTimeStamps(timestamp, prevTimestampPtr, prevMethodPtr, curMethod)
#endif
/*
* native public static long elapsedRealtimeNano();
*/
int64_t elapsedRealtimeNano()
{
#ifdef HAVE_ANDROID_OS
struct timespec ts;
int result;
int64_t timestamp;
#if DEBUG_TIMESTAMP
static volatile int64_t prevTimestamp;
static volatile int prevMethod;
#endif
static int s_fd = -1;
if (s_fd == -1) {
int fd = open("/dev/alarm", O_RDONLY);
if (android_atomic_cmpxchg(-1, fd, &s_fd)) {
close(fd);
}
}
result = ioctl(s_fd,
ANDROID_ALARM_GET_TIME(ANDROID_ALARM_ELAPSED_REALTIME), &ts);
if (result == 0) {
timestamp = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec;
checkTimeStamps(timestamp, &prevTimestamp, &prevMethod, METHOD_IOCTL);
return timestamp;
}
// /dev/alarm doesn't exist, fallback to CLOCK_BOOTTIME
result = clock_gettime(CLOCK_BOOTTIME, &ts);
if (result == 0) {
timestamp = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec;
checkTimeStamps(timestamp, &prevTimestamp, &prevMethod,
METHOD_CLOCK_GETTIME);
return timestamp;
}
// XXX: there was an error, probably because the driver didn't
// exist ... this should return
// a real error, like an exception!
timestamp = systemTime(SYSTEM_TIME_MONOTONIC);
checkTimeStamps(timestamp, &prevTimestamp, &prevMethod,
METHOD_SYSTEMTIME);
return timestamp;
#else
return systemTime(SYSTEM_TIME_MONOTONIC);
#endif
}
}; // namespace android
|
