← Back to branch summary

~ubuntu-branches/ubuntu/maverick/python3.1/maverick

« back to all changes in this revision

Viewing changes to Python/thread_lwp.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-03-23 00:01:27 UTC
  • Revision ID: james.westby@ubuntu.com-20090323000127-5fstfxju4ufrhthq
Tags: upstream-3.1~a1+20090322
Import upstream version 3.1~a1+20090322

Show diffs side-by-side

added added

removed removed

Lines of Context:
Python/thread_lwp.h
 
1
 
 
2
#include <stdlib.h>
 
3
#include <lwp/lwp.h>
 
4
#include <lwp/stackdep.h>
 
5
 
 
6
#define STACKSIZE       1000    /* stacksize for a thread */
 
7
#define NSTACKS         2       /* # stacks to be put in cache initially */
 
8
 
 
9
struct lock {
 
10
        int lock_locked;
 
11
        cv_t lock_condvar;
 
12
        mon_t lock_monitor;
 
13
};
 
14
 
 
15
 
 
16
/*
 
17
 * Initialization.
 
18
 */
 
19
static void PyThread__init_thread(void)
 
20
{
 
21
        lwp_setstkcache(STACKSIZE, NSTACKS);
 
22
}
 
23
 
 
24
/*
 
25
 * Thread support.
 
26
 */
 
27
 
 
28
 
 
29
long PyThread_start_new_thread(void (*func)(void *), void *arg)
 
30
{
 
31
        thread_t tid;
 
32
        int success;
 
33
        dprintf(("PyThread_start_new_thread called\n"));
 
34
        if (!initialized)
 
35
                PyThread_init_thread();
 
36
        success = lwp_create(&tid, func, MINPRIO, 0, lwp_newstk(), 1, arg);
 
37
        return success < 0 ? -1 : 0;
 
38
}
 
39
 
 
40
long PyThread_get_thread_ident(void)
 
41
{
 
42
        thread_t tid;
 
43
        if (!initialized)
 
44
                PyThread_init_thread();
 
45
        if (lwp_self(&tid) < 0)
 
46
                return -1;
 
47
        return tid.thread_id;
 
48
}
 
49
 
 
50
static void do_PyThread_exit_thread(int no_cleanup)
 
51
{
 
52
        dprintf(("PyThread_exit_thread called\n"));
 
53
        if (!initialized)
 
54
                if (no_cleanup)
 
55
                        _exit(0);
 
56
                else
 
57
                        exit(0);
 
58
        lwp_destroy(SELF);
 
59
}
 
60
 
 
61
void PyThread_exit_thread(void)
 
62
{
 
63
        do_PyThread_exit_thread(0);
 
64
}
 
65
 
 
66
void PyThread__exit_thread(void)
 
67
{
 
68
        do_PyThread_exit_thread(1);
 
69
}
 
70
 
 
71
#ifndef NO_EXIT_PROG
 
72
static void do_PyThread_exit_prog(int status, int no_cleanup)
 
73
{
 
74
        dprintf(("PyThread_exit_prog(%d) called\n", status));
 
75
        if (!initialized)
 
76
                if (no_cleanup)
 
77
                        _exit(status);
 
78
                else
 
79
                        exit(status);
 
80
        pod_exit(status);
 
81
}
 
82
 
 
83
void PyThread_exit_prog(int status)
 
84
{
 
85
        do_PyThread_exit_prog(status, 0);
 
86
}
 
87
 
 
88
void PyThread__exit_prog(int status)
 
89
{
 
90
        do_PyThread_exit_prog(status, 1);
 
91
}
 
92
#endif /* NO_EXIT_PROG */
 
93
 
 
94
/*
 
95
 * Lock support.
 
96
 */
 
97
PyThread_type_lock PyThread_allocate_lock(void)
 
98
{
 
99
        struct lock *lock;
 
100
        extern char *malloc(size_t);
 
101
 
 
102
        dprintf(("PyThread_allocate_lock called\n"));
 
103
        if (!initialized)
 
104
                PyThread_init_thread();
 
105
 
 
106
        lock = (struct lock *) malloc(sizeof(struct lock));
 
107
        lock->lock_locked = 0;
 
108
        (void) mon_create(&lock->lock_monitor);
 
109
        (void) cv_create(&lock->lock_condvar, lock->lock_monitor);
 
110
        dprintf(("PyThread_allocate_lock() -> %p\n", lock));
 
111
        return (PyThread_type_lock) lock;
 
112
}
 
113
 
 
114
void PyThread_free_lock(PyThread_type_lock lock)
 
115
{
 
116
        dprintf(("PyThread_free_lock(%p) called\n", lock));
 
117
        mon_destroy(((struct lock *) lock)->lock_monitor);
 
118
        free((char *) lock);
 
119
}
 
120
 
 
121
int PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 
122
{
 
123
        int success;
 
124
 
 
125
        dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
 
126
        success = 0;
 
127
 
 
128
        (void) mon_enter(((struct lock *) lock)->lock_monitor);
 
129
        if (waitflag)
 
130
                while (((struct lock *) lock)->lock_locked)
 
131
                        cv_wait(((struct lock *) lock)->lock_condvar);
 
132
        if (!((struct lock *) lock)->lock_locked) {
 
133
                success = 1;
 
134
                ((struct lock *) lock)->lock_locked = 1;
 
135
        }
 
136
        cv_broadcast(((struct lock *) lock)->lock_condvar);
 
137
        mon_exit(((struct lock *) lock)->lock_monitor);
 
138
        dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
 
139
        return success;
 
140
}
 
141
 
 
142
void PyThread_release_lock(PyThread_type_lock lock)
 
143
{
 
144
        dprintf(("PyThread_release_lock(%p) called\n", lock));
 
145
        (void) mon_enter(((struct lock *) lock)->lock_monitor);
 
146
        ((struct lock *) lock)->lock_locked = 0;
 
147
        cv_broadcast(((struct lock *) lock)->lock_condvar);
 
148
        mon_exit(((struct lock *) lock)->lock_monitor);
 
149
}