GCC Code Coverage Report

Directory: ./
File: src/shared_memory.cpp
Date: 2022-06-30 06:29:57
Exec Total Coverage
Lines: 62 97 63.9%
Branches: 25 81 30.9%
Line Branch Exec Source
1 /**
2 * @file shared_memory.cpp
3 * @author Maximilien Naveau (maximilien.naveau@gmail.com)
4 * @license License BSD-3-Clause
5 * @copyright Copyright (c) 2019, New York University and Max Planck
6 * Gesellschaft.
7 * @date 2019-05-22
8 *
9 * @brief Implementation of the shared_memory.hpp API
10 */
11 #include "shared_memory/shared_memory.hpp"
12
13 namespace bi = boost::interprocess;
14
15 namespace shared_memory
16 {
17 static uint SEGMENT_SIZE = DEFAULT_SHARED_MEMORY_SIZE;
18 static std::mutex SEGMENT_SIZE_MUTEX;
19
20 9 void set_segment_sizes(uint multiplier_1025)
21 {
22 9 SEGMENT_SIZE_MUTEX.lock();
23 9 SEGMENT_SIZE = multiplier_1025 * 1025;
24 9 SEGMENT_SIZE_MUTEX.unlock();
25 9 }
26
27 1 void set_default_segment_sizes()
28 {
29 1 SEGMENT_SIZE_MUTEX.lock();
30 1 SEGMENT_SIZE = DEFAULT_SHARED_MEMORY_SIZE;
31 1 SEGMENT_SIZE_MUTEX.unlock();
32 1 }
33
34 bool VERBOSE = false;
35 54 void set_verbose(bool mode)
36 {
37 54 VERBOSE = mode;
38 54 }
39
40 ✗ static std::chrono::milliseconds time_now()
41 {
42 std::chrono::steady_clock::time_point now =
43 ✗ std::chrono::steady_clock::now();
44 std::chrono::milliseconds m =
45 std::chrono::duration_cast<std::chrono::milliseconds>(
46 ✗ now.time_since_epoch());
47 ✗ return m;
48 }
49
50 ✗ bool wait_for_segment(const std::string &segment_id, int timeout_ms)
51 {
52 ✗ std::chrono::milliseconds start = time_now();
53 ✗ std::chrono::milliseconds timeout{timeout_ms};
54 ✗ bool created = false;
55 ✗ while (!created)
56 {
57 try
58 {
59 ✗ get_segment(segment_id, false, false);
60 ✗ return true;
61 }
62 ✗ catch (const Non_existing_segment_exception &)
63 {
64 ✗ usleep(5);
65 }
66 ✗ if (timeout_ms > 0)
67 {
68 ✗ if (time_now() - start > timeout)
69 {
70 ✗ return false;
71 }
72 }
73 }
74 ✗ return true;
75 }
76
77 /***********************************************
78 * Definition of the SharedMemorySegment class *
79 ***********************************************/
80
81 78 SharedMemorySegment::SharedMemorySegment(std::string segment_id,
82 bool clear_upon_destruction,
83 79 bool create)
84 {
85 // save the id the of the segment
86
1/2
✓ Branch 1 taken 78 times.
✗ Branch 2 not taken.
 78 segment_id_ = segment_id;
87
88 // check if we should delete the memory upon destruction.
89 78 clear_upon_destruction_ = clear_upon_destruction;
90
91 // create and/or map the memory segment
92
1/2
✓ Branch 1 taken 78 times.
✗ Branch 2 not taken.
 78 SEGMENT_SIZE_MUTEX.lock();
93
2/2
✓ Branch 0 taken 77 times.
✓ Branch 1 taken 1 times.
 78 if (create)
94 {
95
3/6
✓ Branch 1 taken 77 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 77 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 77 times.
✗ Branch 9 not taken.
 154 segment_manager_ = boost::interprocess::managed_shared_memory(
96 boost::interprocess::open_or_create,
97 segment_id.c_str(),
98 77 SEGMENT_SIZE);
99 }
100 else
101 {
102 try
103 {
104
2/6
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 9 not taken.
✓ Branch 10 taken 1 times.
 1 segment_manager_ = boost::interprocess::managed_shared_memory(
105 ✗ boost::interprocess::open_only, segment_id.c_str());
106 }
107 2 catch (const boost::interprocess::interprocess_exception &)
108 {
109 1 SEGMENT_SIZE_MUTEX.unlock();
110
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 throw Non_existing_segment_exception(segment_id);
111 }
112 }
113 77 SEGMENT_SIZE_MUTEX.unlock();
114
1/2
✓ Branch 1 taken 77 times.
✗ Branch 2 not taken.
 77 create_mutex();
115 77 }
116
117 ✗ void SharedMemorySegment::clear_memory()
118 {
119 ✗ boost::interprocess::shared_memory_object::remove(segment_id_.c_str());
120 }
121
122 3 void SharedMemorySegment::get_object(const std::string &object_id,
123 std::string &get_)
124 {
125 3 mutex_->lock();
126
127 3 register_object_read_only<char>(object_id);
128
129
2/4
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 3 times.
✗ Branch 6 not taken.
 6 get_ = std::string(static_cast<char *>(objects_[object_id].first),
130
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 objects_[object_id].second);
131
132 3 mutex_->unlock();
133 3 }
134
135 18979 SharedMemorySegment &get_segment(const std::string &segment_id,
136 const bool clear_upon_destruction,
137 const bool create)
138 {
139
2/2
✓ Branch 1 taken 78 times.
✓ Branch 2 taken 18901 times.
 18979 if (GLOBAL_SHM_SEGMENTS.count(segment_id) == 0)
140 {
141 SharedMemorySegment *s =
142
3/4
✓ Branch 2 taken 78 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 77 times.
✓ Branch 6 taken 1 times.
 79 new SharedMemorySegment(segment_id, clear_upon_destruction, create);
143 77 GLOBAL_SHM_SEGMENTS[segment_id].reset(s);
144 }
145 18978 GLOBAL_SHM_SEGMENTS[segment_id]->set_clear_upon_destruction(
146 clear_upon_destruction);
147 18978 return *GLOBAL_SHM_SEGMENTS[segment_id];
148 }
149
150 2 SegmentInfo get_segment_info(const std::string &segment_id)
151 {
152
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 SharedMemorySegment &segment = get_segment(segment_id, false, false);
153
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 SegmentInfo si = segment.get_info();
154 2 return si;
155 }
156
157 ✗ bool segment_exists(const std::string &segment_id)
158 {
159 ✗ if (GLOBAL_SHM_SEGMENTS.count(segment_id) == 0)
160 {
161 ✗ return false;
162 }
163 ✗ return true;
164 }
165
166 28 boost::interprocess::interprocess_mutex &get_segment_mutex(
167 const std::string segment_id)
168 {
169 28 SharedMemorySegment &segment = get_segment(segment_id);
170 28 return *segment.mutex_;
171 }
172
173 106 void delete_segment(const std::string &segment_id)
174 {
175 // here the unique pointer destroy the object for us.
176 106 GLOBAL_SHM_SEGMENTS.erase(segment_id);
177 106 }
178
179 ✗ void delete_all_segment()
180 {
181 ✗ delete_all_segments();
182 }
183
184 ✗ void delete_all_segments()
185 {
186 ✗ for (SegmentMap::iterator seg_it = GLOBAL_SHM_SEGMENTS.begin();
187 ✗ seg_it != GLOBAL_SHM_SEGMENTS.end();
188 seg_it = GLOBAL_SHM_SEGMENTS.begin())
189 {
190 ✗ get_segment(seg_it->second->get_segment_id(), true);
191 ✗ GLOBAL_SHM_SEGMENTS.erase(seg_it);
192 }
193 }
194
195 83 void clear_shared_memory(const std::string &segment_id)
196 {
197 83 boost::interprocess::shared_memory_object::remove(segment_id.c_str());
198 83 delete_segment(segment_id);
199 83 }
200
201 /***********************************
202 * Definition of all set functions *
203 ***********************************/
204
205 3 void set(const std::string &segment_id,
206 const std::string &object_id,
207 const std::string &set_)
208 {
209 3 set<char>(segment_id, object_id, set_.c_str(), set_.size());
210 3 }
211
212 /***********************************
213 * Definition of all get functions *
214 ***********************************/
215
216 3 void get(const std::string &segment_id,
217 const std::string &object_id,
218 std::string &get_,
219 bool create)
220 {
221 try
222 {
223
1/2
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
 3 SharedMemorySegment &segment = get_segment(segment_id, false, create);
224
1/5
✓ Branch 1 taken 3 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
 3 segment.get_object(object_id, get_);
225 }
226 ✗ catch (const boost::interprocess::bad_alloc &)
227 {
228 ✗ throw shared_memory::Allocation_exception(segment_id, object_id);
229 }
230 ✗ catch (const boost::interprocess::interprocess_exception &)
231 {
232 ✗ return;
233 }
234 }
235
236
2/4
✓ Branch 1 taken 54 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 54 times.
✗ Branch 4 not taken.
 162 } // namespace shared_memory
237