Overview
| Comment: | of_condition_t -> OFPlainCondition |
|---|---|
| Downloads: | Tarball | ZIP archive | SQL archive |
| Timelines: | family | ancestors | descendants | both | new-naming-convention |
| Files: | files | file ages | folders |
| SHA3-256: |
20bfedd0b717bd40063dfce8bdc7a692 |
| User & Date: | js on 2021-04-17 16:36:00 |
| Other Links: | branch diff | manifest | tags |
Context
|
2021-04-17
| ||
| 16:40 | of_pbkdf2_parameters_t -> OFPBKDF2Parameters (check-in: a2941ce6a1 user: js tags: new-naming-convention) | |
| 16:36 | of_condition_t -> OFPlainCondition (check-in: 20bfedd0b7 user: js tags: new-naming-convention) | |
| 16:29 | of_spinlock_t -> OFSpinlock (check-in: fabf53041a user: js tags: new-naming-convention) | |
Changes
Modified src/OFCondition.h from [24d692e490] to [c4d6666d7d].
| ︙ | ︙ | |||
25 26 27 28 29 30 31 |
* @class OFCondition OFCondition.h ObjFW/OFCondition.h
*
* @brief A class implementing a condition variable for thread synchronization.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFCondition: OFMutex
{
| | | 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 |
* @class OFCondition OFCondition.h ObjFW/OFCondition.h
*
* @brief A class implementing a condition variable for thread synchronization.
*/
OF_SUBCLASSING_RESTRICTED
@interface OFCondition: OFMutex
{
OFPlainCondition _condition;
bool _conditionInitialized;
}
/**
* @brief Creates a new condition.
*
* @return A new, autoreleased OFCondition
|
| ︙ | ︙ |
Modified src/OFCondition.m from [4b58a9908d] to [df9866904b].
| ︙ | ︙ | |||
32 33 34 35 36 37 38 |
return [[[self alloc] init] autorelease];
}
- (instancetype)init
{
self = [super init];
| | | | | | > | | 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 |
return [[[self alloc] init] autorelease];
}
- (instancetype)init
{
self = [super init];
if (OFPlainConditionNew(&_condition) != 0) {
Class c = self.class;
[self release];
@throw [OFInitializationFailedException exceptionWithClass: c];
}
_conditionInitialized = true;
return self;
}
- (void)dealloc
{
if (_conditionInitialized) {
int error = OFPlainConditionFree(&_condition);
if (error != 0) {
OF_ENSURE(error == EBUSY);
@throw [OFConditionStillWaitingException
exceptionWithCondition: self];
}
}
[super dealloc];
}
- (void)wait
{
int error = OFPlainConditionWait(&_condition, &_mutex);
if (error != 0)
@throw [OFConditionWaitFailedException
exceptionWithCondition: self
errNo: error];
}
#ifdef OF_AMIGAOS
- (void)waitForConditionOrExecSignal: (ULONG *)signalMask
{
int error = OFPlainConditionWaitOrExecSignal(&_condition, &_mutex,
signalMask);
if (error != 0)
@throw [OFConditionWaitFailedException
exceptionWithCondition: self
errNo: error];
}
#endif
- (bool)waitForTimeInterval: (OFTimeInterval)timeInterval
{
int error = OFPlainConditionTimedWait(&_condition, &_mutex,
timeInterval);
if (error == ETIMEDOUT)
return false;
if (error != 0)
@throw [OFConditionWaitFailedException
exceptionWithCondition: self
errNo: error];
return true;
}
#ifdef OF_AMIGAOS
- (bool)waitForTimeInterval: (OFTimeInterval)timeInterval
orExecSignal: (ULONG *)signalMask
{
int error = OFPlainConditionTimedWaitExecOrSignal(&_condition, &_mutex,
timeInterval, signalMask);
if (error == ETIMEDOUT)
return false;
if (error != 0)
@throw [OFConditionWaitFailedException
|
| ︙ | ︙ | |||
131 132 133 134 135 136 137 |
return [self waitForTimeInterval: date.timeIntervalSinceNow
orExecSignal: signalMask];
}
#endif
- (void)signal
{
| | | | 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 |
return [self waitForTimeInterval: date.timeIntervalSinceNow
orExecSignal: signalMask];
}
#endif
- (void)signal
{
int error = OFPlainConditionSignal(&_condition);
if (error != 0)
@throw [OFConditionSignalFailedException
exceptionWithCondition: self
errNo: error];
}
- (void)broadcast
{
int error = OFPlainConditionBroadcast(&_condition);
if (error != 0)
@throw [OFConditionBroadcastFailedException
exceptionWithCondition: self
errNo: error];
}
@end
|
Modified src/condition.h from [1ee99bce0d] to [d04b4d971e].
| ︙ | ︙ | |||
25 26 27 28 29 30 31 | /* For OFTimeInterval */ #import "OFObject.h" #import "mutex.h" #if defined(OF_HAVE_PTHREADS) # include <pthread.h> | | | | | | | | > | | | | | | | 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 |
/* For OFTimeInterval */
#import "OFObject.h"
#import "mutex.h"
#if defined(OF_HAVE_PTHREADS)
# include <pthread.h>
typedef pthread_cond_t OFPlainCondition;
#elif defined(OF_WINDOWS)
# include <windows.h>
typedef struct {
HANDLE event;
volatile int count;
} OFPlainCondition;
#elif defined(OF_AMIGAOS)
# include <exec/tasks.h>
typedef struct {
struct OFPlainConditionWaitingTask {
struct Task *task;
unsigned char sigBit;
struct OFPlainConditionWaitingTask *next;
} *waitingTasks;
} OFPlainCondition;
#endif
#ifdef __cplusplus
extern "C" {
#endif
extern int OFPlainConditionNew(OFPlainCondition *condition);
extern int OFPlainConditionSignal(OFPlainCondition *condition);
extern int OFPlainConditionBroadcast(OFPlainCondition *condition);
extern int OFPlainConditionWait(OFPlainCondition *condition,
OFPlainMutex *mutex);
extern int OFPlainConditionTimedWait(OFPlainCondition *condition,
OFPlainMutex *mutex, OFTimeInterval timeout);
#ifdef OF_AMIGAOS
extern int OFPlainConditionWaitOrExecSignal(OFPlainCondition *condition,
OFPlainMutex *mutex, ULONG *signalMask);
extern int OFPlainConditionTimedWaitOrExecSignal(OFPlainCondition *condition,
OFPlainMutex *mutex, OFTimeInterval timeout, ULONG *signalMask);
#endif
extern int OFPlainConditionFree(OFPlainCondition *condition);
#ifdef __cplusplus
}
#endif
|
Modified src/platform/amiga/condition.m from [cc3230123e] to [c1fcab92ba].
| ︙ | ︙ | |||
22 23 24 25 26 27 28 | #include <proto/exec.h> #include <devices/timer.h> #ifndef OF_AMIGAOS4 # include <clib/alib_protos.h> #endif int | | | | | | | | | | 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 |
#include <proto/exec.h>
#include <devices/timer.h>
#ifndef OF_AMIGAOS4
# include <clib/alib_protos.h>
#endif
int
OFPlainConditionNew(OFPlainCondition *condition)
{
condition->waitingTasks = NULL;
return 0;
}
int
OFPlainConditionSignal(OFPlainCondition *condition)
{
Forbid();
@try {
if (condition->waitingTasks == NULL)
return 0;
Signal(condition->waitingTasks->task,
(1ul << condition->waitingTasks->sigBit));
condition->waitingTasks = condition->waitingTasks->next;
} @finally {
Permit();
}
return 0;
}
int
OFPlainConditionBroadcast(OFPlainCondition *condition)
{
Forbid();
@try {
if (condition->waitingTasks == NULL)
return 0;
while (condition->waitingTasks != NULL) {
Signal(condition->waitingTasks->task,
(1ul << condition->waitingTasks->sigBit));
condition->waitingTasks = condition->waitingTasks->next;
}
} @finally {
Permit();
}
return 0;
}
int
OFPlainConditionWait(OFPlainCondition *condition, OFPlainMutex *mutex)
{
ULONG signalMask = 0;
return OFPlainConditionWaitOrExecSignal(condition, mutex, &signalMask);
}
int
OFPlainConditionWaitOrExecSignal(OFPlainCondition *condition,
OFPlainMutex *mutex, ULONG *signalMask)
{
struct OFPlainConditionWaitingTask waitingTask = {
.task = FindTask(NULL),
.sigBit = AllocSignal(-1)
};
int error = 0;
ULONG mask;
if (waitingTask.sigBit == -1)
|
| ︙ | ︙ | |||
119 120 121 122 123 124 125 | Permit(); return error; } int | | | | | | 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 |
Permit();
return error;
}
int
OFPlainConditionTimedWait(OFPlainCondition *condition, OFPlainMutex *mutex,
OFTimeInterval timeout)
{
ULONG signalMask = 0;
return OFPlainConditionTimedWaitOrExecSignal(condition, mutex, timeout,
&signalMask);
}
int
OFPlainConditionTimedWaitOrExecSignal(OFPlainCondition *condition,
OFPlainMutex *mutex, OFTimeInterval timeout, ULONG *signalMask)
{
struct OFPlainConditionWaitingTask waitingTask = {
.task = FindTask(NULL),
.sigBit = AllocSignal(-1)
};
struct MsgPort port = {
.mp_Node = {
.ln_Type = NT_MSGPORT
},
|
| ︙ | ︙ | |||
233 234 235 236 237 238 239 | if (port.mp_SigBit != -1) FreeSignal(port.mp_SigBit); return error; } int | | | 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 |
if (port.mp_SigBit != -1)
FreeSignal(port.mp_SigBit);
return error;
}
int
OFPlainConditionFree(OFPlainCondition *condition)
{
Forbid();
@try {
if (condition->waitingTasks != NULL)
return EBUSY;
} @finally {
Permit();
}
return 0;
}
|
Modified src/platform/posix/condition.m from [04e776f8bc] to [f355e9c12d].
| ︙ | ︙ | |||
14 15 16 17 18 19 20 | */ #include "config.h" #import "condition.h" int | | | | | | | | 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 |
*/
#include "config.h"
#import "condition.h"
int
OFPlainConditionNew(OFPlainCondition *condition)
{
return pthread_cond_init(condition, NULL);
}
int
OFPlainConditionSignal(OFPlainCondition *condition)
{
return pthread_cond_signal(condition);
}
int
OFPlainConditionBroadcast(OFPlainCondition *condition)
{
return pthread_cond_broadcast(condition);
}
int
OFPlainConditionWait(OFPlainCondition *condition, OFPlainMutex *mutex)
{
return pthread_cond_wait(condition, mutex);
}
int
OFPlainConditionTimedWait(OFPlainCondition *condition, OFPlainMutex *mutex,
OFTimeInterval timeout)
{
struct timespec ts;
ts.tv_sec = (time_t)timeout;
ts.tv_nsec = (long)((timeout - ts.tv_sec) * 1000000000);
return pthread_cond_timedwait(condition, mutex, &ts);
}
int
OFPlainConditionFree(OFPlainCondition *condition)
{
return pthread_cond_destroy(condition);
}
|
Modified src/platform/windows/condition.m from [33e65b6da7] to [5e19c9c3c0].
| ︙ | ︙ | |||
18 19 20 21 22 23 24 | #include <errno.h> #import "condition.h" #include <windows.h> int | | | | | | 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 |
#include <errno.h>
#import "condition.h"
#include <windows.h>
int
OFPlainConditionNew(OFPlainCondition *condition)
{
condition->count = 0;
if ((condition->event = CreateEvent(NULL, FALSE, 0, NULL)) == NULL)
return EAGAIN;
return 0;
}
int
OFPlainConditionSignal(OFPlainCondition *condition)
{
if (!SetEvent(condition->event)) {
switch (GetLastError()) {
case ERROR_INVALID_HANDLE:
return EINVAL;
default:
OF_ENSURE(0);
}
}
return 0;
}
int
OFPlainConditionBroadcast(OFPlainCondition *condition)
{
int count = condition->count;
for (int i = 0; i < count; i++) {
if (!SetEvent(condition->event)) {
switch (GetLastError()) {
case ERROR_INVALID_HANDLE:
return EINVAL;
default:
OF_ENSURE(0);
}
}
}
return 0;
}
int
OFPlainConditionWait(OFPlainCondition *condition, OFPlainMutex *mutex)
{
int error;
DWORD status;
if ((error = OFPlainMutexUnlock(mutex)) != 0)
return error;
|
| ︙ | ︙ | |||
91 92 93 94 95 96 97 | } default: OF_ENSURE(0); } } int | | | 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 |
}
default:
OF_ENSURE(0);
}
}
int
OFPlainConditionTimedWait(OFPlainCondition *condition, OFPlainMutex *mutex,
OFTimeInterval timeout)
{
int error;
DWORD status;
if ((error = OFPlainMutexUnlock(mutex)) != 0)
return error;
|
| ︙ | ︙ | |||
122 123 124 125 126 127 128 | } default: OF_ENSURE(0); } } int | | | 122 123 124 125 126 127 128 129 130 131 132 133 134 135 |
}
default:
OF_ENSURE(0);
}
}
int
OFPlainConditionFree(OFPlainCondition *condition)
{
if (condition->count != 0)
return EBUSY;
return (CloseHandle(condition->event) ? 0 : EINVAL);
}
|