1
2
3
4
5
6
7
8
9
10
11
12
13
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
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
|
/*
* Copyright 2015 Google Inc.
*
* Use of this source code is governed by a BSD-style license that can be
* found in the LICENSE file.
*/
#ifndef SkSemaphore_DEFINED
#define SkSemaphore_DEFINED
#include "SkTypes.h"
#include "../private/SkAtomics.h"
#include "../private/SkOncePtr.h"
struct SkBaseSemaphore {
// Increment the counter by 1.
// This is a specialization for supporting SkMutex.
void signal() {
// Since this fetches the value before the add, 0 indicates that this thread is running and
// no threads are waiting, -1 and below means that threads are waiting, but only signal 1
// thread to run.
if (sk_atomic_fetch_add(&fCount, 1, sk_memory_order_release) < 0) {
this->osSignal(1);
}
}
// Increment the counter N times.
// Generally it's better to call signal(N) instead of signal() N times.
void signal(int N);
// Decrement the counter by 1,
// then if the counter is <= 0, sleep this thread until the counter is > 0.
void wait() {
// Since this fetches the value before the subtract, zero and below means that there are no
// resources left, so the thread needs to wait.
if (sk_atomic_fetch_sub(&fCount, 1, sk_memory_order_acquire) <= 0) {
this->osWait();
}
}
struct OSSemaphore;
void osSignal(int n);
void osWait();
void deleteSemaphore();
// This implementation follows the general strategy of
// 'A Lightweight Semaphore with Partial Spinning'
// found here
// http://preshing.com/20150316/semaphores-are-surprisingly-versatile/
// That article (and entire blog) are very much worth reading.
//
// We wrap an OS-provided semaphore with a user-space atomic counter that
// lets us avoid interacting with the OS semaphore unless strictly required:
// moving the count from >0 to <=0 or vice-versa, i.e. sleeping or waking threads.
int fCount;
SkBaseOncePtr<OSSemaphore> fOSSemaphore;
};
/**
* SkSemaphore is a fast mostly-user-space semaphore.
*
* A semaphore is logically an atomic integer with a few special properties:
* - The integer always starts at 0.
* - You can only increment or decrement it, never read or write it.
* - Increment is spelled 'signal()'; decrement is spelled 'wait()'.
* - If a call to wait() decrements the counter to <= 0,
* the calling thread sleeps until another thread signal()s it back above 0.
*/
class SkSemaphore : SkNoncopyable {
public:
// Initializes the counter to 0.
// (Though all current implementations could start from an arbitrary value.)
SkSemaphore();
~SkSemaphore();
void wait();
void signal(int n = 1);
private:
SkBaseSemaphore fBaseSemaphore;
};
#endif//SkSemaphore_DEFINED
|
