python/Python/thread_sgi.h at master · technomalogical/python · GitHub

History

375 lines (347 loc) · 9.39 KB

Raw

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

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

358

359

360

361

362

363

364

365

366

367

368

369

370

371

372

373

374

375

#include <stdlib.h>

#include <stdio.h>

#include <signal.h>

#include <sys/types.h>

#include <sys/wait.h>

#include <sys/prctl.h>

#include <ulocks.h>

#include <errno.h>

#define HDR_SIZE 2680 /* sizeof(ushdr_t) */

#define MAXPROC 100 /* max # of threads that can be started */

static usptr_t *shared_arena;

static ulock_t count_lock; /* protection for some variables */

static ulock_t wait_lock; /* lock used to wait for other threads */

static int waiting_for_threads; /* protected by count_lock */

static int nthreads; /* protected by count_lock */

static int exit_status;

#ifndef NO_EXIT_PROG

static int do_exit; /* indicates that the program is to exit */

#endif

static int exiting; /* we're already exiting (for maybe_exit) */

static pid_t my_pid; /* PID of main thread */

static struct pidlist {

pid_t parent;

pid_t child;

} pidlist[MAXPROC]; /* PIDs of other threads; protected by count_lock */

static int maxpidindex; /* # of PIDs in pidlist */

#ifndef NO_EXIT_PROG

* This routine is called as a signal handler when another thread

* exits. When that happens, we must see whether we have to exit as

* well (because of an PyThread_exit_prog()) or whether we should continue on.

static void exit_sig(void)

{

d2printf(("exit_sig called\n"));

if (exiting && getpid() == my_pid) {

d2printf(("already exiting\n"));

return;

}

if (do_exit) {

d2printf(("exiting in exit_sig\n"));

#ifdef Py_DEBUG

if ((thread_debug & 8) == 0)

thread_debug &= ~1; /* don't produce debug messages */

#endif

PyThread_exit_thread();

}

* This routine is called when a process calls exit(). If that wasn't

* done from the library, we do as if an PyThread_exit_prog() was intended.

static void maybe_exit(void)

{

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

if (exiting) {

dprintf(("already exiting\n"));

return;

}

PyThread_exit_prog(0);

}

#endif /* NO_EXIT_PROG */

* Initialization.

static void PyThread__init_thread(void)

{

#ifndef NO_EXIT_PROG

struct sigaction s;

#endif /* NO_EXIT_PROG */

#ifdef USE_DL

long addr, size;

#endif /* USE_DL */

#ifdef USE_DL

if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)

perror("usconfig - CONF_INITSIZE (check)");

if (usconfig(CONF_INITSIZE, size) < 0)

perror("usconfig - CONF_INITSIZE (reset)");

addr = (long) dl_getrange(size + HDR_SIZE);

dprintf(("trying to use addr %p-%p for shared arena\n", addr, addr+size));

errno = 0;

if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 && errno != 0)

perror("usconfig - CONF_ATTACHADDR (set)");

#endif /* USE_DL */

if (usconfig(CONF_INITUSERS, 16) < 0)

perror("usconfig - CONF_INITUSERS");

my_pid = getpid(); /* so that we know which is the main thread */

#ifndef NO_EXIT_PROG

atexit(maybe_exit);

s.sa_handler = exit_sig;

sigemptyset(&s.sa_mask);

/*sigaddset(&s.sa_mask, SIGUSR1);*/

s.sa_flags = 0;

sigaction(SIGUSR1, &s, 0);

if (prctl(PR_SETEXITSIG, SIGUSR1) < 0)

perror("prctl - PR_SETEXITSIG");

#endif /* NO_EXIT_PROG */

if (usconfig(CONF_ARENATYPE, US_SHAREDONLY) < 0)

perror("usconfig - CONF_ARENATYPE");

usconfig(CONF_LOCKTYPE, US_DEBUG); /* XXX */

#ifdef Py_DEBUG

if (thread_debug & 4)

usconfig(CONF_LOCKTYPE, US_DEBUGPLUS);

else if (thread_debug & 2)

usconfig(CONF_LOCKTYPE, US_DEBUG);

#endif /* Py_DEBUG */

if ((shared_arena = usinit(tmpnam(0))) == 0)

perror("usinit");

#ifdef USE_DL

if (usconfig(CONF_ATTACHADDR, addr) < 0) /* reset address */

perror("usconfig - CONF_ATTACHADDR (reset)");

#endif /* USE_DL */

if ((count_lock = usnewlock(shared_arena)) == NULL)

perror("usnewlock (count_lock)");

(void) usinitlock(count_lock);

if ((wait_lock = usnewlock(shared_arena)) == NULL)

perror("usnewlock (wait_lock)");

dprintf(("arena start: %p, arena size: %ld\n", shared_arena, (long) usconfig(CONF_GETSIZE, shared_arena)));

}

* Thread support.

static void clean_threads(void)

{

int i, j;

pid_t mypid, pid;

/* clean up any exited threads */

mypid = getpid();

i = 0;

while (i < maxpidindex) {

if (pidlist[i].parent == mypid && (pid = pidlist[i].child) > 0) {

pid = waitpid(pid, 0, WNOHANG);

if (pid > 0) {

/* a thread has exited */

pidlist[i] = pidlist[--maxpidindex];

/* remove references to children of dead proc */

for (j = 0; j < maxpidindex; j++)

if (pidlist[j].parent == pid)

pidlist[j].child = -1;

continue; /* don't increment i */

}

i++;

}

/* clean up the list */

i = 0;

while (i < maxpidindex) {

if (pidlist[i].child == -1) {

pidlist[i] = pidlist[--maxpidindex];

continue; /* don't increment i */

}

i++;

}

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

{

#ifdef USE_DL

long addr, size;

static int local_initialized = 0;

#endif /* USE_DL */

int success = 0; /* init not needed when SOLARIS_THREADS and */

/* C_THREADS implemented properly */

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

if (!initialized)

PyThread_init_thread();

switch (ussetlock(count_lock)) {

case 0: return 0;

case -1: perror("ussetlock (count_lock)");

}

if (maxpidindex >= MAXPROC)

success = -1;

else {

#ifdef USE_DL

if (!local_initialized) {

if ((size = usconfig(CONF_INITSIZE, 64*1024)) < 0)

perror("usconfig - CONF_INITSIZE (check)");

if (usconfig(CONF_INITSIZE, size) < 0)

perror("usconfig - CONF_INITSIZE (reset)");

addr = (long) dl_getrange(size + HDR_SIZE);

dprintf(("trying to use addr %p-%p for sproc\n",

addr, addr+size));

errno = 0;

if ((addr = usconfig(CONF_ATTACHADDR, addr)) < 0 &&

errno != 0)

perror("usconfig - CONF_ATTACHADDR (set)");

}

#endif /* USE_DL */

clean_threads();

if ((success = sproc(func, PR_SALL, arg)) < 0)

perror("sproc");

#ifdef USE_DL

if (!local_initialized) {

if (usconfig(CONF_ATTACHADDR, addr) < 0)

/* reset address */

perror("usconfig - CONF_ATTACHADDR (reset)");

local_initialized = 1;

}

#endif /* USE_DL */

if (success >= 0) {

nthreads++;

pidlist[maxpidindex].parent = getpid();

pidlist[maxpidindex++].child = success;

dprintf(("pidlist[%d] = %d\n",

maxpidindex-1, success));

}

if (usunsetlock(count_lock) < 0)

perror("usunsetlock (count_lock)");

return success;

}

long PyThread_get_thread_ident(void)

{

return getpid();

}

static void do_PyThread_exit_thread(int no_cleanup)

{

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

if (!initialized)

if (no_cleanup)

_exit(0);

else

exit(0);

if (ussetlock(count_lock) < 0)

perror("ussetlock (count_lock)");

nthreads--;

if (getpid() == my_pid) {

/* main thread; wait for other threads to exit */

exiting = 1;

#ifndef NO_EXIT_PROG

if (do_exit) {

int i;

/* notify other threads */

clean_threads();

if (nthreads >= 0) {

dprintf(("kill other threads\n"));

for (i = 0; i < maxpidindex; i++)

if (pidlist[i].child > 0)

(void) kill(pidlist[i].child,

SIGKILL);

_exit(exit_status);

}

#endif /* NO_EXIT_PROG */

waiting_for_threads = 1;

if (ussetlock(wait_lock) < 0)

perror("ussetlock (wait_lock)");

for (;;) {

if (nthreads < 0) {

dprintf(("really exit (%d)\n", exit_status));

if (no_cleanup)

_exit(exit_status);

else

exit(exit_status);

}

if (usunsetlock(count_lock) < 0)

perror("usunsetlock (count_lock)");

dprintf(("waiting for other threads (%d)\n", nthreads));

if (ussetlock(wait_lock) < 0)

perror("ussetlock (wait_lock)");

if (ussetlock(count_lock) < 0)

perror("ussetlock (count_lock)");

}

/* not the main thread */

if (waiting_for_threads) {

dprintf(("main thread is waiting\n"));

if (usunsetlock(wait_lock) < 0)

perror("usunsetlock (wait_lock)");

}

#ifndef NO_EXIT_PROG

else if (do_exit)

(void) kill(my_pid, SIGUSR1);

#endif /* NO_EXIT_PROG */

if (usunsetlock(count_lock) < 0)

perror("usunsetlock (count_lock)");

_exit(0);

}

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));

if (!initialized)

if (no_cleanup)

_exit(status);

else

exit(status);

do_exit = 1;

exit_status = status;

do_PyThread_exit_thread(no_cleanup);

}

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.

PyThread_type_lock PyThread_allocate_lock(void)

{

ulock_t lock;

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

if (!initialized)

PyThread_init_thread();

if ((lock = usnewlock(shared_arena)) == NULL)

perror("usnewlock");

(void) usinitlock(lock);

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

return (PyThread_type_lock) lock;

}

void PyThread_free_lock(PyThread_type_lock lock)

{

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

usfreelock((ulock_t) lock, shared_arena);

}

int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)

{

int success;

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

errno = 0; /* clear it just in case */

if (waitflag)

success = ussetlock((ulock_t) lock);

else

success = uscsetlock((ulock_t) lock, 1); /* Try it once */

if (success < 0)

perror(waitflag ? "ussetlock" : "uscsetlock");

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

return success;

}

void PyThread_release_lock(PyThread_type_lock lock)

{

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

if (usunsetlock((ulock_t) lock) < 0)

perror("usunsetlock");

}

python/Python/thread_sgi.h at master · technomalogical/python · GitHub

Expand file tree

Breadcrumbs

thread_sgi.h

Latest commit

History

Breadcrumbs

thread_sgi.h

File metadata and controls