]>
Commit | Line | Data |
---|---|---|
adca27eb JH |
1 | /** |
2 | * @file job_queue.c | |
3 | * | |
4 | * @brief Job-Queue based on linked_list_t | |
5 | * | |
6 | */ | |
7 | ||
8 | /* | |
9 | * Copyright (C) 2005 Jan Hutter, Martin Willi | |
10 | * Hochschule fuer Technik Rapperswil | |
11 | * | |
12 | * This program is free software; you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License as published by the | |
14 | * Free Software Foundation; either version 2 of the License, or (at your | |
15 | * option) any later version. See <http://www.fsf.org/copyleft/gpl.txt>. | |
16 | * | |
17 | * This program is distributed in the hope that it will be useful, but | |
18 | * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY | |
19 | * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License | |
20 | * for more details. | |
21 | */ | |
22 | ||
23 | //#include <stdlib.h> | |
24 | #include <pthread.h> | |
25 | #include <freeswan.h> | |
26 | #include <pluto/constants.h> | |
27 | #include <pluto/defs.h> | |
28 | ||
29 | #include "job_queue.h" | |
30 | ||
31 | /** | |
32 | * @brief implements function destroy of job_t | |
33 | */ | |
34 | static status_t job_destroy(job_t *job) | |
35 | { | |
36 | pfree(job); | |
37 | return SUCCESS; | |
38 | } | |
39 | ||
40 | /* | |
41 | * Creates a job (documented in header-file) | |
42 | */ | |
43 | job_t *job_create(job_type_t type, void *assigned_data) | |
44 | { | |
45 | job_t *this = alloc_thing(job_t, "job_t"); | |
46 | ||
47 | this->destroy = job_destroy; | |
48 | ||
49 | this->type = type; | |
50 | this->assigned_data = assigned_data; | |
51 | ||
52 | return this; | |
53 | } | |
54 | ||
55 | /** | |
56 | * @brief Private Variables and Functions of job_queue class | |
57 | * | |
58 | */ | |
59 | typedef struct private_job_queue_s private_job_queue_t; | |
60 | ||
61 | ||
62 | struct private_job_queue_s { | |
63 | job_queue_t public; | |
64 | ||
65 | /** | |
66 | * The jobs are stored in a linked list | |
67 | */ | |
68 | linked_list_t *list; | |
69 | /** | |
70 | * access to linked_list is locked through this mutex | |
71 | */ | |
72 | pthread_mutex_t mutex; | |
73 | ||
74 | /** | |
75 | * If the queue is empty a thread has to wait | |
76 | * This condvar is used to wake up such a thread | |
77 | */ | |
78 | pthread_cond_t condvar; | |
79 | }; | |
80 | ||
81 | ||
82 | /** | |
83 | * @brief implements function get_count of job_queue_t | |
84 | */ | |
85 | status_t get_count(job_queue_t *job_queue, int *count) | |
86 | { | |
87 | private_job_queue_t *this = (private_job_queue_t *) job_queue; | |
88 | pthread_mutex_lock(&(this->mutex)); | |
89 | *count = this->list->count; | |
90 | pthread_mutex_unlock(&(this->mutex)); | |
91 | return SUCCESS; | |
92 | } | |
93 | ||
94 | /** | |
95 | * @brief implements function get of job_queue_t | |
96 | */ | |
97 | status_t get(job_queue_t *job_queue, job_t **job) | |
98 | { | |
99 | private_job_queue_t *this = (private_job_queue_t *) job_queue; | |
100 | pthread_mutex_lock(&(this->mutex)); | |
101 | while(this->list->count == 0) | |
102 | { | |
103 | pthread_cond_wait( &(this->condvar), &(this->mutex)); | |
104 | } | |
105 | this->list->remove_first(this->list,(void **) job); | |
106 | pthread_mutex_unlock(&(this->mutex)); | |
107 | return SUCCESS; | |
108 | } | |
109 | ||
110 | /** | |
111 | * @brief implements function add of job_queue_t | |
112 | */ | |
113 | status_t add(job_queue_t *job_queue, job_t *job) | |
114 | { | |
115 | private_job_queue_t *this = (private_job_queue_t *) job_queue; | |
116 | pthread_mutex_lock(&(this->mutex)); | |
117 | this->list->insert_last(this->list,job); | |
118 | pthread_cond_signal( &(this->condvar)); | |
119 | pthread_mutex_unlock(&(this->mutex)); | |
120 | return SUCCESS; | |
121 | } | |
122 | ||
123 | /** | |
124 | * @brief implements function destroy of job_queue_t | |
125 | * | |
126 | */ | |
127 | status_t job_queue_destroy (job_queue_t *job_queue) | |
128 | { | |
129 | private_job_queue_t *this = (private_job_queue_t *) job_queue; | |
130 | ||
131 | while (this->list->count > 0) | |
132 | { | |
133 | job_t *job; | |
134 | if (this->list->remove_first(this->list,(void *) &job) != SUCCESS) | |
135 | { | |
136 | this->list->destroy(this->list); | |
137 | break; | |
138 | } | |
139 | job->destroy(job); | |
140 | } | |
141 | this->list->destroy(this->list); | |
142 | ||
143 | pthread_mutex_destroy(&(this->mutex)); | |
144 | ||
145 | pthread_cond_destroy(&(this->condvar)); | |
146 | ||
147 | pfree(this); | |
148 | return SUCCESS; | |
149 | } | |
150 | ||
151 | /* | |
152 | * | |
153 | * Documented in header | |
154 | */ | |
155 | job_queue_t *job_queue_create() | |
156 | { | |
157 | linked_list_t *linked_list = linked_list_create(); | |
158 | if (linked_list == NULL) | |
159 | { | |
160 | return NULL; | |
161 | } | |
162 | ||
163 | private_job_queue_t *this = alloc_thing(private_job_queue_t, "private_job_queue_t"); | |
164 | if (this == NULL) | |
165 | { | |
166 | linked_list->destroy(linked_list); | |
167 | return NULL; | |
168 | } | |
169 | ||
170 | this->public.get_count = get_count; | |
171 | this->public.get = get; | |
172 | this->public.add = add; | |
173 | this->public.destroy = job_queue_destroy; | |
174 | ||
175 | this->list = linked_list; | |
176 | pthread_mutex_init(&(this->mutex), NULL); | |
177 | pthread_cond_init(&(this->condvar), NULL); | |
178 | ||
179 | return (&this->public); | |
180 | } |