blob: 0cd6b8f969c8ce904eb2be48b9399a3b3319a025 (
plain)
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
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
117
118
119
120
121
122
123
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef CEPH_REFCOUNTEDOBJ_H
#define CEPH_REFCOUNTEDOBJ_H
#include "include/atomic.h"
#include "common/Mutex.h"
#include "common/Cond.h"
struct RefCountedObject {
atomic_t nref;
RefCountedObject() : nref(1) {}
virtual ~RefCountedObject() {}
RefCountedObject *get() {
//generic_dout(0) << "RefCountedObject::get " << this << " " << nref.read() << " -> " << (nref.read() + 1) << dendl;
nref.inc();
return this;
}
void put() {
//generic_dout(0) << "RefCountedObject::put " << this << " " << nref.read() << " -> " << (nref.read() - 1) << dendl;
if (nref.dec() == 0)
delete this;
}
};
/**
* RefCountedCond
*
* a refcounted condition, will be removed when all references are dropped
*/
struct RefCountedCond : public RefCountedObject {
bool complete;
Mutex lock;
Cond cond;
RefCountedCond() : complete(false), lock("RefCountedCond") {}
void wait() {
Mutex::Locker l(lock);
while (!complete) {
cond.Wait(lock);
}
}
void done() {
Mutex::Locker l(lock);
complete = true;
cond.SignalAll();
}
};
/**
* RefCountedWaitObject
*
* refcounted object that allows waiting for the object's last reference.
* Any referrer can either put or put_wait(). A simple put() will return
* immediately, a put_wait() will return only when the object is destroyed.
* e.g., useful when we want to wait for a specific event completion. We
* use RefCountedCond, as the condition can be referenced after the object
* destruction.
*
*/
struct RefCountedWaitObject {
atomic_t nref;
RefCountedCond *c;
RefCountedWaitObject() : nref(1) {
c = new RefCountedCond;
}
virtual ~RefCountedWaitObject() {
c->put();
}
RefCountedWaitObject *get() {
nref.inc();
return this;
}
bool put() {
bool ret = false;
RefCountedCond *cond = c;
cond->get();
if (nref.dec() == 0) {
cond->done();
delete this;
ret = true;
}
cond->put();
return ret;
}
void put_wait() {
RefCountedCond *cond = c;
cond->get();
if (nref.dec() == 0) {
cond->done();
delete this;
} else {
cond->wait();
}
cond->put();
}
};
void intrusive_ptr_add_ref(RefCountedObject *p);
void intrusive_ptr_release(RefCountedObject *p);
#endif
|
