FilesExpand file tree

master

/

thread_atheos.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

executable file

·

259 lines (206 loc) · 5.84 KB

master

/

thread_atheos.h

Copy path

Top

File metadata and controls

• Code
• Blame

executable file

·

259 lines (206 loc) · 5.84 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

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

/* Threading for AtheOS.

Based on thread_beos.h. */

#include <atheos/threads.h>

#include <atheos/semaphore.h>

#include <atheos/atomic.h>

#include <errno.h>

#include <string.h>

/* Missing decl from threads.h */

extern int exit_thread(int);

/* Undefine FASTLOCK to play with simple semaphores. */

#define FASTLOCK

#ifdef FASTLOCK

/* Use an atomic counter and a semaphore for maximum speed. */

typedef struct fastmutex {

sem_id sem;

atomic_t count;

} fastmutex_t;

static int fastmutex_create(const char *name, fastmutex_t * mutex);

static int fastmutex_destroy(fastmutex_t * mutex);

static int fastmutex_lock(fastmutex_t * mutex);

static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout);

static int fastmutex_unlock(fastmutex_t * mutex);

static int fastmutex_create(const char *name, fastmutex_t * mutex)

{

mutex->count = 0;

mutex->sem = create_semaphore(name, 0, 0);

return (mutex->sem < 0) ? -1 : 0;

}

static int fastmutex_destroy(fastmutex_t * mutex)

{

if (fastmutex_timedlock(mutex, 0) == 0 || errno == EWOULDBLOCK) {

return delete_semaphore(mutex->sem);

}

return 0;

}

static int fastmutex_lock(fastmutex_t * mutex)

{

atomic_t prev = atomic_add(&mutex->count, 1);

if (prev > 0)

return lock_semaphore(mutex->sem);

return 0;

}

static int fastmutex_timedlock(fastmutex_t * mutex, bigtime_t timeout)

{

atomic_t prev = atomic_add(&mutex->count, 1);

if (prev > 0)

return lock_semaphore_x(mutex->sem, 1, 0, timeout);

return 0;

}

static int fastmutex_unlock(fastmutex_t * mutex)

{

atomic_t prev = atomic_add(&mutex->count, -1);

if (prev > 1)

return unlock_semaphore(mutex->sem);

return 0;

}

#endif /* FASTLOCK */

/*

* Initialization.

*

*/

static void PyThread__init_thread(void)

{

/* Do nothing. */

return;

}

/*

* Thread support.

*

*/

static atomic_t thread_count = 0;

long PyThread_start_new_thread(void (*func) (void *), void *arg)

{

status_t success = -1;

thread_id tid;

char name[OS_NAME_LENGTH];

atomic_t this_thread;

dprintf(("PyThread_start_new_thread called\n"));

this_thread = atomic_add(&thread_count, 1);

PyOS_snprintf(name, sizeof(name), "python thread (%d)", this_thread);

tid = spawn_thread(name, func, NORMAL_PRIORITY, 0, arg);

if (tid < 0) {

dprintf(("PyThread_start_new_thread spawn_thread failed: %s\n", strerror(errno)));

} else {

success = resume_thread(tid);

if (success < 0) {

dprintf(("PyThread_start_new_thread resume_thread failed: %s\n", strerror(errno)));

}

}

return (success < 0 ? -1 : tid);

}

long PyThread_get_thread_ident(void)

{

return get_thread_id(NULL);

}

void PyThread_exit_thread(void)

{

dprintf(("PyThread_exit_thread called\n"));

/* Thread-safe way to read a variable without a mutex: */

if (atomic_add(&thread_count, 0) == 0) {

/* No threads around, so exit main(). */

exit(0);

} else {

/* We're a thread */

exit_thread(0);

}

}

/*

* Lock support.

*

*/

static atomic_t lock_count = 0;

PyThread_type_lock PyThread_allocate_lock(void)

{

#ifdef FASTLOCK

fastmutex_t *lock;

#else

sem_id sema;

#endif

char name[OS_NAME_LENGTH];

atomic_t this_lock;

dprintf(("PyThread_allocate_lock called\n"));

#ifdef FASTLOCK

lock = (fastmutex_t *) malloc(sizeof(fastmutex_t));

if (lock == NULL) {

dprintf(("PyThread_allocate_lock failed: out of memory\n"));

return (PyThread_type_lock) NULL;

}

#endif

this_lock = atomic_add(&lock_count, 1);

PyOS_snprintf(name, sizeof(name), "python lock (%d)", this_lock);

#ifdef FASTLOCK

if (fastmutex_create(name, lock) < 0) {

dprintf(("PyThread_allocate_lock failed: %s\n",

strerror(errno)));

free(lock);

lock = NULL;

}

dprintf(("PyThread_allocate_lock()-> %p\n", lock));

return (PyThread_type_lock) lock;

#else

sema = create_semaphore(name, 1, 0);

if (sema < 0) {

dprintf(("PyThread_allocate_lock failed: %s\n",

strerror(errno)));

sema = 0;

}

dprintf(("PyThread_allocate_lock()-> %p\n", sema));

return (PyThread_type_lock) sema;

#endif

}

void PyThread_free_lock(PyThread_type_lock lock)

{

dprintf(("PyThread_free_lock(%p) called\n", lock));

#ifdef FASTLOCK

if (fastmutex_destroy((fastmutex_t *) lock) < 0) {

dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,

strerror(errno)));

}

free(lock);

#else

if (delete_semaphore((sem_id) lock) < 0) {

dprintf(("PyThread_free_lock(%p) failed: %s\n", lock,

strerror(errno)));

}

#endif

}

int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)

{

int retval;

dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock,

waitflag));

#ifdef FASTLOCK

if (waitflag)

retval = fastmutex_lock((fastmutex_t *) lock);

else

retval = fastmutex_timedlock((fastmutex_t *) lock, 0);

#else

if (waitflag)

retval = lock_semaphore((sem_id) lock);

else

retval = lock_semaphore_x((sem_id) lock, 1, 0, 0);

#endif

if (retval < 0) {

dprintf(("PyThread_acquire_lock(%p, %d) failed: %s\n",

lock, waitflag, strerror(errno)));

}

dprintf(("PyThread_acquire_lock(%p, %d)-> %d\n", lock, waitflag,

retval));

return retval < 0 ? 0 : 1;

}

void PyThread_release_lock(PyThread_type_lock lock)

{

dprintf(("PyThread_release_lock(%p) called\n", lock));

#ifdef FASTLOCK

if (fastmutex_unlock((fastmutex_t *) lock) < 0) {

dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,

strerror(errno)));

}

#else

if (unlock_semaphore((sem_id) lock) < 0) {

dprintf(("PyThread_release_lock(%p) failed: %s\n", lock,

strerror(errno)));

}

#endif

}