← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Python/thread_cthread.h

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Python/thread_cthread.h
 
1
 
 
2
#ifdef MACH_C_THREADS
 
3
#include <mach/cthreads.h>
 
4
#endif
 
5
 
 
6
#ifdef HURD_C_THREADS
 
7
#include <cthreads.h>
 
8
#endif
 
9
 
 
10
/*
 
11
 * Initialization.
 
12
 */
 
13
static void
 
14
PyThread__init_thread(void)
 
15
{
 
16
#ifndef HURD_C_THREADS
 
17
        /* Roland McGrath said this should not be used since this is
 
18
        done while linking to threads */
 
19
        cthread_init(); 
 
20
#else
 
21
/* do nothing */
 
22
        ;
 
23
#endif
 
24
}
 
25
 
 
26
/*
 
27
 * Thread support.
 
28
 */
 
29
long
 
30
PyThread_start_new_thread(void (*func)(void *), void *arg)
 
31
{
 
32
        int success = 0;        /* init not needed when SOLARIS_THREADS and */
 
33
                                /* C_THREADS implemented properly */
 
34
 
 
35
        dprintf(("PyThread_start_new_thread called\n"));
 
36
        if (!initialized)
 
37
                PyThread_init_thread();
 
38
        /* looks like solaris detaches the thread to never rejoin
 
39
         * so well do it here
 
40
         */
 
41
        cthread_detach(cthread_fork((cthread_fn_t) func, arg));
 
42
        return success < 0 ? -1 : 0;
 
43
}
 
44
 
 
45
long
 
46
PyThread_get_thread_ident(void)
 
47
{
 
48
        if (!initialized)
 
49
                PyThread_init_thread();
 
50
        return (long) cthread_self();
 
51
}
 
52
 
 
53
static void
 
54
do_PyThread_exit_thread(int no_cleanup)
 
55
{
 
56
        dprintf(("PyThread_exit_thread called\n"));
 
57
        if (!initialized)
 
58
                if (no_cleanup)
 
59
                        _exit(0);
 
60
                else
 
61
                        exit(0);
 
62
        cthread_exit(0);
 
63
}
 
64
 
 
65
void
 
66
PyThread_exit_thread(void)
 
67
{
 
68
        do_PyThread_exit_thread(0);
 
69
}
 
70
 
 
71
void
 
72
PyThread__exit_thread(void)
 
73
{
 
74
        do_PyThread_exit_thread(1);
 
75
}
 
76
 
 
77
#ifndef NO_EXIT_PROG
 
78
static
 
79
void do_PyThread_exit_prog(int status, int no_cleanup)
 
80
{
 
81
        dprintf(("PyThread_exit_prog(%d) called\n", status));
 
82
        if (!initialized)
 
83
                if (no_cleanup)
 
84
                        _exit(status);
 
85
                else
 
86
                        exit(status);
 
87
        if (no_cleanup)
 
88
                _exit(status);
 
89
        else
 
90
                exit(status);
 
91
}
 
92
 
 
93
void
 
94
PyThread_exit_prog(int status)
 
95
{
 
96
        do_PyThread_exit_prog(status, 0);
 
97
}
 
98
 
 
99
void
 
100
PyThread__exit_prog(int status)
 
101
{
 
102
        do_PyThread_exit_prog(status, 1);
 
103
}
 
104
#endif /* NO_EXIT_PROG */
 
105
 
 
106
/*
 
107
 * Lock support.
 
108
 */
 
109
PyThread_type_lock
 
110
PyThread_allocate_lock(void)
 
111
{
 
112
        mutex_t lock;
 
113
 
 
114
        dprintf(("PyThread_allocate_lock called\n"));
 
115
        if (!initialized)
 
116
                PyThread_init_thread();
 
117
 
 
118
        lock = mutex_alloc();
 
119
        if (mutex_init(lock)) {
 
120
                perror("mutex_init");
 
121
                free((void *) lock);
 
122
                lock = 0;
 
123
        }
 
124
        dprintf(("PyThread_allocate_lock() -> %p\n", lock));
 
125
        return (PyThread_type_lock) lock;
 
126
}
 
127
 
 
128
void
 
129
PyThread_free_lock(PyThread_type_lock lock)
 
130
{
 
131
        dprintf(("PyThread_free_lock(%p) called\n", lock));
 
132
        mutex_free(lock);
 
133
}
 
134
 
 
135
int
 
136
PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
 
137
{
 
138
        int success = FALSE;
 
139
 
 
140
        dprintf(("PyThread_acquire_lock(%p, %d) called\n", lock, waitflag));
 
141
        if (waitflag) {         /* blocking */
 
142
                mutex_lock((mutex_t)lock);
 
143
                success = TRUE;
 
144
        } else {                /* non blocking */
 
145
                success = mutex_try_lock((mutex_t)lock);
 
146
        }
 
147
        dprintf(("PyThread_acquire_lock(%p, %d) -> %d\n", lock, waitflag, success));
 
148
        return success;
 
149
}
 
150
 
 
151
void
 
152
PyThread_release_lock(PyThread_type_lock lock)
 
153
{
 
154
        dprintf(("PyThread_release_lock(%p) called\n", lock));
 
155
        mutex_unlock((mutex_t )lock);
 
156
}