FilesExpand file tree

 master

/

tr2_tls.c

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

174 lines (132 loc) · 3.96 KB

 master

/

tr2_tls.c

Copy path

Top

File metadata and controls

• Code
• Blame

174 lines (132 loc) · 3.96 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

#include "cache.h"

#include "thread-utils.h"

#include "trace2/tr2_tls.h"

/*

* Initialize size of the thread stack for nested regions.

* This is used to store nested region start times. Note that

* this stack is per-thread and not per-trace-key.

*/

#define TR2_REGION_NESTING_INITIAL_SIZE (100)

static struct tr2tls_thread_ctx *tr2tls_thread_main;

static uint64_t tr2tls_us_start_process;

static pthread_mutex_t tr2tls_mutex;

static pthread_key_t tr2tls_key;

static int tr2_next_thread_id; /* modify under lock */

void tr2tls_start_process_clock(void)

{

if (tr2tls_us_start_process)

return;

/*

* Keep the absolute start time of the process (i.e. the main

* process) in a fixed variable since other threads need to

* access it. This allows them to do that without a lock on

* main thread's array data (because of reallocs).

*/

tr2tls_us_start_process = getnanotime() / 1000;

}

struct tr2tls_thread_ctx *tr2tls_create_self(const char *thread_name,

uint64_t us_thread_start)

{

struct tr2tls_thread_ctx *ctx = xcalloc(1, sizeof(*ctx));

/*

* Implicitly "tr2tls_push_self()" to capture the thread's start

* time in array_us_start[0]. For the main thread this gives us the

* application run time.

*/

ctx->alloc = TR2_REGION_NESTING_INITIAL_SIZE;

ctx->array_us_start = (uint64_t *)xcalloc(ctx->alloc, sizeof(uint64_t));

ctx->array_us_start[ctx->nr_open_regions++] = us_thread_start;

ctx->thread_id = tr2tls_locked_increment(&tr2_next_thread_id);

strbuf_init(&ctx->thread_name, 0);

if (ctx->thread_id)

strbuf_addf(&ctx->thread_name, "th%02d:", ctx->thread_id);

strbuf_addstr(&ctx->thread_name, thread_name);

if (ctx->thread_name.len > TR2_MAX_THREAD_NAME)

strbuf_setlen(&ctx->thread_name, TR2_MAX_THREAD_NAME);

pthread_setspecific(tr2tls_key, ctx);

return ctx;

}

struct tr2tls_thread_ctx *tr2tls_get_self(void)

{

struct tr2tls_thread_ctx *ctx = pthread_getspecific(tr2tls_key);

/*

* If the thread-proc did not call trace2_thread_start(), we won't

* have any TLS data associated with the current thread. Fix it

* here and silently continue.

*/

if (!ctx)

ctx = tr2tls_create_self("unknown", getnanotime() / 1000);

return ctx;

}

int tr2tls_is_main_thread(void)

{

struct tr2tls_thread_ctx *ctx = pthread_getspecific(tr2tls_key);

return ctx == tr2tls_thread_main;

}

void tr2tls_unset_self(void)

{

struct tr2tls_thread_ctx *ctx;

ctx = tr2tls_get_self();

pthread_setspecific(tr2tls_key, NULL);

free(ctx->array_us_start);

free(ctx);

}

void tr2tls_push_self(uint64_t us_now)

{

struct tr2tls_thread_ctx *ctx = tr2tls_get_self();

ALLOC_GROW(ctx->array_us_start, ctx->nr_open_regions + 1, ctx->alloc);

ctx->array_us_start[ctx->nr_open_regions++] = us_now;

}

void tr2tls_pop_self(void)

{

struct tr2tls_thread_ctx *ctx = tr2tls_get_self();

if (!ctx->nr_open_regions)

BUG("no open regions in thread '%s'", ctx->thread_name.buf);

ctx->nr_open_regions--;

}

void tr2tls_pop_unwind_self(void)

{

struct tr2tls_thread_ctx *ctx = tr2tls_get_self();

while (ctx->nr_open_regions > 1)

tr2tls_pop_self();

}

uint64_t tr2tls_region_elasped_self(uint64_t us)

{

struct tr2tls_thread_ctx *ctx;

uint64_t us_start;

ctx = tr2tls_get_self();

if (!ctx->nr_open_regions)

return 0;

us_start = ctx->array_us_start[ctx->nr_open_regions - 1];

return us - us_start;

}

uint64_t tr2tls_absolute_elapsed(uint64_t us)

{

if (!tr2tls_thread_main)

return 0;

return us - tr2tls_us_start_process;

}

void tr2tls_init(void)

{

tr2tls_start_process_clock();

pthread_key_create(&tr2tls_key, NULL);

init_recursive_mutex(&tr2tls_mutex);

tr2tls_thread_main =

tr2tls_create_self("main", tr2tls_us_start_process);

}

void tr2tls_release(void)

{

tr2tls_unset_self();

tr2tls_thread_main = NULL;

pthread_mutex_destroy(&tr2tls_mutex);

pthread_key_delete(tr2tls_key);

}

int tr2tls_locked_increment(int *p)

{

int current_value;

pthread_mutex_lock(&tr2tls_mutex);

current_value = *p;

*p = current_value + 1;

pthread_mutex_unlock(&tr2tls_mutex);

return current_value;

}