FilesExpand file tree

 master

/

thread_beos.h

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

287 lines (227 loc) · 6.02 KB

 master

/

thread_beos.h

Copy path

Top

File metadata and controls

• Code
• Blame

287 lines (227 loc) · 6.02 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

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

#include <kernel/OS.h>

#include <support/SupportDefs.h>

#include <errno.h>

/* ----------------------------------------------------------------------

* Fast locking mechanism described by Benoit Schillings (benoit@be.com)

* in the Be Developer's Newsletter, Issue #26 (http://www.be.com/).

*/

typedef struct benaphore {

sem_id _sem;

int32 _atom;

} benaphore_t;

static status_t benaphore_create( const char *name, benaphore_t *ben );

static status_t benaphore_destroy( benaphore_t *ben );

static status_t benaphore_lock( benaphore_t *ben );

static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros );

static status_t benaphore_unlock( benaphore_t *ben );

static status_t benaphore_create( const char *name, benaphore_t *ben )

{

if( ben != NULL ) {

ben->_atom = 0;

ben->_sem = create_sem( 0, name );

if( ben->_sem < B_NO_ERROR ) {

return B_BAD_SEM_ID;

}

} else {

return EFAULT;

}

return EOK;

}

static status_t benaphore_destroy( benaphore_t *ben )

{

if( ben->_sem >= B_NO_ERROR ) {

status_t retval = benaphore_timedlock( ben, 0 );

if( retval == EOK || retval == EWOULDBLOCK ) {

status_t del_retval = delete_sem( ben->_sem );

return del_retval;

}

}

return B_BAD_SEM_ID;

}

static status_t benaphore_lock( benaphore_t *ben )

{

int32 prev = atomic_add( &(ben->_atom), 1 );

if( prev > 0 ) {

return acquire_sem( ben->_sem );

}

return EOK;

}

static status_t benaphore_timedlock( benaphore_t *ben, bigtime_t micros )

{

int32 prev = atomic_add( &(ben->_atom), 1 );

if( prev > 0 ) {

status_t retval = acquire_sem_etc( ben->_sem, 1, B_TIMEOUT, micros );

switch( retval ) {

case B_WOULD_BLOCK: /* Fall through... */

case B_TIMED_OUT:

return EWOULDBLOCK;

break;

case B_OK:

return EOK;

break;

default:

return retval;

break;

}

}

return EOK;

}

static status_t benaphore_unlock( benaphore_t *ben )

{

int32 prev = atomic_add( &(ben->_atom), -1 );

if( prev > 1 ) {

return release_sem( ben->_sem );

}

return EOK;

}

/* ----------------------------------------------------------------------

* Initialization.

*/

static void PyThread__init_thread( void )

{

/* Do nothing. */

return;

}

/* ----------------------------------------------------------------------

* Thread support.

*

* Only ANSI C, renamed functions here; you can't use K&R on BeOS,

* and there's no legacy thread module to support.

*/

static int32 thread_count = 0;

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

{

status_t success = 0;

thread_id tid;

char name[B_OS_NAME_LENGTH];

int32 this_thread;

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

/* We are so very thread-safe... */

this_thread = atomic_add( &thread_count, 1 );

PyOS_snprintf(name, sizeof(name),

"python thread (%d)", this_thread );

tid = spawn_thread( (thread_func)func, name,

B_NORMAL_PRIORITY, arg );

if( tid > B_NO_ERROR ) {

success = resume_thread( tid );

}

return ( success == B_NO_ERROR ? tid : -1 );

}

long PyThread_get_thread_ident( void )

{

/* Presumed to return the current thread's ID... */

thread_id tid;

tid = find_thread( NULL );

return ( tid != B_NAME_NOT_FOUND ? tid : -1 );

}

static void do_PyThread_exit_thread( int no_cleanup )

{

int32 threads;

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

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

threads = atomic_add( &thread_count, 0 );

if( threads == 0 ) {

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

if( no_cleanup ) {

_exit(0);

} else {

exit(0);

}

} else {

/* Oh, we're a thread, let's try to exit gracefully... */

exit_thread( B_NO_ERROR );

}

}

void PyThread_exit_thread( void )

{

do_PyThread_exit_thread(0);

}

void PyThread__exit_thread( void )

{

do_PyThread_exit_thread(1);

}

#ifndef NO_EXIT_PROG

static void do_PyThread_exit_prog( int status, int no_cleanup )

{

dprintf(("PyThread_exit_prog(%d) called\n", status));

/* No need to do anything, the threads get torn down if main() exits. */

if (no_cleanup) {

_exit(status);

} else {

exit(status);

}

}

void PyThread_exit_prog( int status )

{

do_PyThread_exit_prog(status, 0);

}

void PyThread__exit_prog( int status )

{

do_PyThread_exit_prog(status, 1);

}

#endif /* NO_EXIT_PROG */

/* ----------------------------------------------------------------------

* Lock support.

*/

static int32 lock_count = 0;

PyThread_type_lock PyThread_allocate_lock( void )

{

benaphore_t *lock;

status_t retval;

char name[B_OS_NAME_LENGTH];

int32 this_lock;

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

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

if( lock == NULL ) {

/* TODO: that's bad, raise MemoryError */

return (PyThread_type_lock)NULL;

}

this_lock = atomic_add( &lock_count, 1 );

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

retval = benaphore_create( name, lock );

if( retval != EOK ) {

/* TODO: that's bad, raise an exception */

return (PyThread_type_lock)NULL;

}

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

return (PyThread_type_lock) lock;

}

void PyThread_free_lock( PyThread_type_lock lock )

{

status_t retval;

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

retval = benaphore_destroy( (benaphore_t *)lock );

if( retval != EOK ) {

/* TODO: that's bad, raise an exception */

return;

}

}

int PyThread_acquire_lock( PyThread_type_lock lock, int waitflag )

{

int success;

status_t retval;

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

if( waitflag ) {

retval = benaphore_lock( (benaphore_t *)lock );

} else {

retval = benaphore_timedlock( (benaphore_t *)lock, 0 );

}

if( retval == EOK ) {

success = 1;

} else {

success = 0;

/* TODO: that's bad, raise an exception */

}

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

return success;

}

void PyThread_release_lock( PyThread_type_lock lock )

{

status_t retval;

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

retval = benaphore_unlock( (benaphore_t *)lock );

if( retval != EOK ) {

/* TODO: that's bad, raise an exception */

return;

}

}