I am writing a c++ program and I want a program where there are two processes (running with fork()) and they both share a common list and an interprocess mutex is there to guard the shared list modifications from each process. How can I declare the list and the mutex so that they are shared among processes?
I can use boost library if needed (and if it makes things easier)
New contributor
ALEXIS LAZANAS is a new contributor to this site. Take care in asking for clarification, commenting, and answering.
Check out our Code of Conduct.
2
The absolute simplest way is to reopen after fork. That way you never risk any unspecified (or undefined) behavior.
Complete example: Live On Coliru
#include <boost/container/map.hpp>
#include <boost/container/scoped_allocator.hpp>
#include <boost/container/string.hpp>
#include <boost/container/vector.hpp>
#include <boost/interprocess/managed_shared_memory.hpp>
#include <boost/interprocess/sync/interprocess_mutex.hpp>
#include <fmt/ranges.h>
#include <iostream>
#include <thread>
using namespace std::chrono_literals;
namespace Shared {
namespace bc = boost::container;
namespace bip = boost::interprocess;
using Segment = bip::managed_shared_memory;
using Manager = Segment::segment_manager;
template <typename T> using Alloc = bc::scoped_allocator_adaptor<bip::allocator<T, Manager>>;
template <typename T> using Vector = bc::vector<T, Alloc<T>>;
template <typename K, typename V, typename C = std::less<K>>
using Map = bc::map<K, V, C, Alloc<std::pair<K const, V>>>;
using String = bc::basic_string<char, std::char_traits<char>, Alloc<char>>;
struct MyData {
using allocator_type = Alloc<MyData>;
template <typename A> MyData(A&& alloc) : data_(std::forward<A>(alloc)) {}
size_t count() const {
for (std::lock_guard lk(mx_);;)
return data_.size();
}
void set(std::string_view key, std::initializer_list<int> values) {
std::lock_guard lk(mx_);
if (auto it = data_.find(key); it != data_.end())
it->second.assign(values.begin(), values.end());
else
data_.emplace(key, std::move(values));
}
void remove(std::string_view key) {
std::lock_guard lk(mx_);
data_.erase(key);
}
void print() const {
std::lock_guard lk(mx_);
for (auto& [key, values] : data_)
fmt::print(" {}: {}n", key, values);
}
private:
mutable bip::interprocess_mutex mx_;
struct KeyCmp : std::less<std::string_view> { using is_transparent = void; };
Map<String, Vector<int>, KeyCmp> data_;
};
} // namespace Shared
static constexpr auto SegmentName = "MySharedMemory";
int parent() {
using namespace Shared;
Segment segment(bip::open_only, SegmentName);
auto [myData, N] = segment.find<MyData>("MyData");
assert(N == 1); // not an array
std::this_thread::sleep_for(1s);
myData->set("foo", {1, 2, 3, 4, 5});
std::this_thread::sleep_for(1s);
myData->set("bar", {6, 7, 8, 9, 10});
std::this_thread::sleep_for(1s);
myData->set("foo", {5, 4, 3, 2, 1});
std::this_thread::sleep_for(1s);
myData->remove("bar");
std::cout << "parent done" << std::endl;
return 0;
}
int child() {
using namespace Shared;
Segment segment(bip::open_only, SegmentName);
auto [myData, N] = segment.find<MyData>("MyData");
assert(N == 1); // not an array
for (int i : {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}) {
std::this_thread::sleep_for(500ms);
std::cout << "child foo #" << i << ": " << myData->count() << "n";
myData->print();
}
std::cout << "child done" << std::endl;
return 0;
}
int main() {
{
using namespace Shared;
Segment::device_type::remove(SegmentName);
Segment segment(bip::create_only, SegmentName, 64 << 20ul); // 64MiB
segment.find_or_construct<MyData>("MyData")(segment.get_segment_manager());
}
return fork()? parent() : child();
}
Printing:
1