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
124
125
126
127
128
129
130
131
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
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
//////////////////////////////////////////////////////////////////////////////
//
// (C) Copyright Ion Gaztanaga 2005-2011. Distributed under the Boost
// Software License, Version 1.0. (See accompanying file
// LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// See http://www.boost.org/libs/interprocess for documentation.
//
//////////////////////////////////////////////////////////////////////////////
#ifndef BOOST_INTERPROCESS_DETAIL_SYNC_UTILS_HPP
#define BOOST_INTERPROCESS_DETAIL_SYNC_UTILS_HPP
#if (defined _MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif
#include <boost/interprocess/detail/config_begin.hpp>
#include <boost/interprocess/detail/workaround.hpp>
#include <boost/interprocess/detail/win32_api.hpp>
#include <boost/interprocess/sync/spin/mutex.hpp>
#include <boost/interprocess/exceptions.hpp>
#include <boost/interprocess/sync/scoped_lock.hpp>
#include <boost/unordered/unordered_map.hpp>
#include <cstddef>
namespace boost {
namespace interprocess {
namespace ipcdetail {
inline bool bytes_to_str(const void *mem, const std::size_t mem_length, char *out_str, std::size_t &out_length)
{
const std::size_t need_mem = mem_length*2+1;
if(out_length < need_mem){
return false;
}
const char Characters [] =
{ '0', '1', '2', '3', '4', '5', '6', '7'
, '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' };
std::size_t char_counter = 0;
const char *buf = (const char *)mem;
for(std::size_t i = 0; i != mem_length; ++i){
out_str[char_counter++] = Characters[(buf[i]&0xF0)>>4];
out_str[char_counter++] = Characters[(buf[i]&0x0F)];
}
out_str[char_counter] = 0;
return true;
}
struct sync_id
{
sync_id()
{ winapi::query_performance_counter(&rand); }
__int64 rand;
friend std::size_t hash_value(const sync_id &m)
{ return boost::hash_value(m.rand); }
friend bool operator==(const sync_id &l, const sync_id &r)
{ return l.rand == r.rand; }
};
/*
#define BOOST_NO_LONG_LONG ss
#if defined(BOOST_NO_LONG_LONG)
#error "defined(BOOST_NO_LONG_LONG)"
#else
#error "NOT defined(BOOST_NO_LONG_LONG)"
#endif
*/
class sync_handles
{
public:
enum type { MUTEX, SEMAPHORE };
private:
typedef boost::unordered_map<sync_id, void*> map_type;
static const std::size_t LengthOfGlobal = sizeof("Global\\boost.ipc")-1;
static const std::size_t StrSize = LengthOfGlobal + (sizeof(sync_id)*2+1);
typedef char NameBuf[StrSize];
void fill_name(NameBuf &name, const sync_id &id)
{
const char *n = "Global\\boost.ipc";
std::size_t i = 0;
do{
name[i] = n[i];
++i;
} while(n[i]);
std::size_t len = sizeof(NameBuf) - LengthOfGlobal;
bytes_to_str(&id.rand, sizeof(id.rand), &name[LengthOfGlobal], len);
}
void erase_and_throw_if_error(void *hnd_val, const sync_id &id)
{
if(!hnd_val){
map_.erase(id);
error_info err(winapi::get_last_error());
throw interprocess_exception(err);
}
}
void* open_or_create_semaphore(const sync_id &id, unsigned int initial_count)
{
NameBuf name;
fill_name(name, id);
void *hnd_val = winapi::open_or_create_semaphore
(name, (long)initial_count, (long)(((unsigned long)(-1))>>1), unrestricted_security.get_attributes());
erase_and_throw_if_error(hnd_val, id);
return hnd_val;
}
void* open_or_create_mutex(const sync_id &id)
{
NameBuf name;
fill_name(name, id);
void *hnd_val = winapi::open_or_create_mutex
(name, false, unrestricted_security.get_attributes());
erase_and_throw_if_error(hnd_val, id);
return hnd_val;
}
public:
void *obtain_mutex(const sync_id &id, bool *popen_created = 0)
{
scoped_lock<spin_mutex> lock(mtx_);
void *&hnd_val = map_[id];
if(!hnd_val){
hnd_val = open_or_create_mutex(id);
if(popen_created) *popen_created = true;
}
return hnd_val;
}
void *obtain_semaphore(const sync_id &id, unsigned int initial_count, bool *popen_created = 0)
{
scoped_lock<spin_mutex> lock(mtx_);
void *&hnd_val = map_[id];
if(!hnd_val){
hnd_val = open_or_create_semaphore(id, initial_count);
if(popen_created) *popen_created = true;
}
return hnd_val;
}
void destroy_handle(const sync_id &id)
{
scoped_lock<spin_mutex> lock(mtx_);
map_type::iterator it = map_.find(id);
if(it != map_.end()){
winapi::close_handle(it->second);
map_.erase(it);
}
}
private:
winapi::interprocess_all_access_security unrestricted_security;
spin_mutex mtx_;
map_type map_;
};
} //namespace ipcdetail {
} //namespace interprocess {
} //namespace boost {
#include <boost/interprocess/detail/config_end.hpp>
#endif //BOOST_INTERPROCESS_DETAIL_SYNC_UTILS_HPP
|
