oceanbase

1
#include <sys/time.h>
2
#include <math.h>
3
#include "util/easy_util.h"
4
#include "io/easy_log.h"
5

6
#define STACK_BT_BUFFER_LENGTH 2048
7
#define MEASUREMENTS 200
8
#define USECSTEP 10
9
#define USECSTART 100
10
static const double EASY_DOUBLE_EPSINON = 1e-14;
11
extern char *parray_c(char *buf, int64_t len, int64_t *array, int size);
12
const char *easy_lbt()
13
{
14
    static __thread void *addrs[100];
15
    static __thread char buf[1024];
16
    int size = ob_backtrace_c(addrs, 100);
17
    return parray_c(buf, sizeof(buf), (int64_t *)addrs, size);
18
}
19

20
const char *easy_lbt_str()
21
{
22
    static __thread void *addrs[100];
23
    static __thread char buf[STACK_BT_BUFFER_LENGTH];
24
    int size, len, pos = 0;
25
    char **symbols = NULL;
26
    char *sym;
27
    int idx;
28

29
    sprintf(buf, "\n");
30
    pos++;
31

32
    size    = ob_backtrace_c(addrs, 100);
33
    symbols = backtrace_symbols(addrs, 100);
34
    if (NULL == symbols) {
35
        return buf;
36
    }
37

38
    for (idx = 0; idx < size; idx++) {
39
        sym = symbols[idx];
40
        if (NULL != sym) {
41
            len = strlen(sym);
42
            if ((pos + len + 1) > STACK_BT_BUFFER_LENGTH) {
43
                break;
44
            } else {
45
                sprintf(buf + pos, "%s\n", sym);
46
                pos += len + 1;
47
            }
48
        }
49
    }
50

51
    free(symbols);
52
    return buf;
53
}
54

55
const char* easy_get_func_name(void *addr)
56
{
57
    char *func_name = "";
58
    char **res;
59

60
    res = backtrace_symbols(&addr, 1);
61
    if (res != NULL) {
62
        func_name = res[0];
63
        free(res);
64
    }
65

66
    return func_name;
67
}
68

69
/*
70
 * Use linear regression to calculate cycles per microsecond.
71
 */
72
static double sample_get_cpu_mhz(void)
73
{
74
    struct timeval tv1, tv2;
75
    cycles_t start;
76
    double sx = 0, sy = 0, sxx = 0, syy = 0, sxy = 0;
77
    double tx, ty;
78
    int i;
79

80
    /* Regression: y = a + b x */
81
    long x[MEASUREMENTS];
82
    cycles_t y[MEASUREMENTS];
83
    // double a; /* system call overhead in cycles */
84
    double b; /* cycles per microsecond */
85
    double r_2;
86

87
    for (i = 0; i < MEASUREMENTS; ++i) {
88
        start = easy_get_cycles();
89

90
        if (gettimeofday(&tv1, NULL)) {
91
            easy_error_log("gettimeofday failed.\n");
92
            return 0;
93
        }
94

95
        do {
96
            if (gettimeofday(&tv2, NULL)) {
97
                easy_error_log("gettimeofday failed.\n");
98
                return 0;
99
            }
100
        } while ((tv2.tv_sec - tv1.tv_sec) * 1000000 +
101
                 (tv2.tv_usec - tv1.tv_usec) < USECSTART + i * USECSTEP);
102

103
        x[i] = (tv2.tv_sec - tv1.tv_sec) * 1000000 +
104
               tv2.tv_usec - tv1.tv_usec;
105
        y[i] = easy_get_cycles() - start;
106
        // if (DEBUG_DATA)
107
        // DEBUG("x=%ld y=%Ld.\n", x[i], (long long)y[i]);
108
    }
109

110
    for (i = 0; i < MEASUREMENTS; ++i) {
111
        tx = x[i];
112
        ty = y[i];
113
        sx += tx;
114
        sy += ty;
115
        sxx += tx * tx;
116
        syy += ty * ty;
117
        sxy += tx * ty;
118
    }
119

120
    b = (MEASUREMENTS * sxy - sx * sy) / (MEASUREMENTS * sxx - sx * sx);
121
    // a = (sy - b * sx) / MEASUREMENTS;
122
    // DEBUG("a = %g\n", a);
123
    // DEBUG("b = %g\n", b);
124
    // DEBUG("a / b = %g\n", a / b);
125
    r_2 = (MEASUREMENTS * sxy - sx * sy) *
126
          (MEASUREMENTS * sxy - sx * sy) /
127
          (MEASUREMENTS * sxx - sx * sx) /
128
          (MEASUREMENTS * syy - sy * sy);
129

130
    // DEBUG("r^2 = %g\n", r_2);
131
    if (r_2 < 0.9) {
132
        easy_error_log("Correlation coefficient r^2: %g < 0.9.\n", r_2);
133
        return 0;
134
    }
135

136
    return b;
137
}
138

139
static double proc_get_cpu_mhz(int no_cpu_freq_fail)
140
{
141
    FILE *f;
142
    char buf[256];
143
    double mhz = 0.0;
144

145
    f = fopen("/proc/cpuinfo", "r");
146
    if (!f) {
147
        return 0.0;
148
    }
149

150
    while (fgets(buf, sizeof(buf), f)) {
151
        double m;
152
        int rc;
153
        rc = sscanf(buf, "cpu MHz : %lf", &m);
154
        if (rc != 1) {	/* PPC has a different format */
155
            rc = sscanf(buf, "clock : %lf", &m);
156
            if (rc != 1) {
157
                continue;
158
            }
159
        }
160
        if (fabs(mhz) < EASY_DOUBLE_EPSINON) {
161
            mhz = m;
162
            continue;
163
        }
164
        if (fabs(mhz - m) > EASY_DOUBLE_EPSINON) {
165
            // DEBUG("Conflicting CPU frequency values detected: %lf != %lf.\n", mhz, m);
166
            if (no_cpu_freq_fail) {
167
                // DEBUG("Test integrity may be harmed!\n");
168
            } else {
169
                fclose(f);
170
                return 0.0;
171
            }
172
            continue;
173
        }
174
    }
175
    fclose(f);
176
    return mhz;
177
}
178

179
double easy_get_cpu_mhz(int no_cpu_freq_fail)
180
{
181
    double sample, proc, delta;
182
    sample = sample_get_cpu_mhz();
183
    proc = proc_get_cpu_mhz(no_cpu_freq_fail);
184

185
    easy_debug_log("Got CPU mhz, sample(%lf), proc(%lf).\n", sample, proc);
186
	if ((fabs(proc) < EASY_DOUBLE_EPSINON) ||
187
		(fabs(sample) < EASY_DOUBLE_EPSINON)) {
188
		return 0;
189
	}
190

191
    delta = proc > sample ? proc - sample : sample - proc;
192
    if (delta / proc > 0.01) {
193
        easy_warn_log("Measured timestamp frequency %g differs from nominal %g MHz.\n", sample, proc);
194
        return sample;
195
    }
196
    return proc;
197
}
198