- Boost-users - lists.boost.org

Re: [Boost-users] [beast] I can't write a hello world server
by Senthil Cheetancheri 10 Apr '24

10 Apr '24

(Trying to repost because the previous message was rejected due to size limits.) Hi Loup, The reason I'm taking the time to ask here is because I feel there is something fundamental, likely obvious to the experts, that I don't understand about how beast (and, I'm guessing, asio) works, and how I'm supposed to use it. It seems like you are quite comfortable with C++. That is good because it is a necessary background for this. Boost.Asio and .Beast are inherently advanced topics. The examples use quite advanced C++ knowledge. It could appear simple to experts who understand asio and C++, as well as to newcomers if they were lucky to get the right orientation when they began to learn C++. I had to unlearn a lot of 'C' and old C++ notions. Here are some resources that helped me reach the Aha! moment after a lot of struggles. They are all well worth the patient time you will need. (They are from my bookmarks and are a bit dated. You can easily get the corresponding latest versions.) 1. ASIO: https://www.boost.org/doc/libs/1_79_0/doc/html/boost_asio.html 2. Beast: Watch this video https://youtu.be/7FQwAjELMek at the bottom of the tutorials page https://www.boost.org/doc/libs/1_80_0/libs/beast/doc/html/beast/examples.ht…. This video was a turning point for me. 3. If you would like interactive help, join the #beast channel of the cpplang slack https://cppalliance.org/slack/. They are very kind and super helpful. When you get asio and beast to work well, they are beautiful and give you joy. HTH. Thanks, Senthil.

2 3

Boost.ASIO C++ 20 coroutine equivalent of PPL task_completion_event or JavaScript Promise.resolve?
by Willem Mitchell 09 Apr '24

09 Apr '24

I'm trying to write a simple ASIO send/receiver that uses message queueing. The goal is to have a number of virtual streams over a single TCP connection. This is pretty simple using callbacks, but I can't figure out the coroutines alternative. Here is my simplified sample code. Note that I'm using asio::experimental::promise the same way I would use std::promise which obviously doesn't work, but it illustrates what I'm trying to do. What is the simplest solution to my problem? #pragma once #include "asio.hpp" #include "asio/co_spawn.hpp" #include "asio/detached.hpp" #include "asio/experimental/co_composed.hpp" #include "asio/experimental/promise.hpp" #include "asio/use_awaitable.hpp" #include <coroutine> #include <cstdint> #include <map> #include <memory> #include <queue> struct Message { uint64_t id; uint64_t streamId; uint64_t priority; }; class NetworkConnection { public: NetworkConnection(asio::io_context &ioContext) : ioContext_(ioContext), sendTimer_(ioContext_), receiveTimer_(ioContext_){}; asio::awaitable<std::unique_ptr<Message>> receive(uint64_t streamId) { auto promise = std::make_shared< asio::experimental::promise<std::unique_ptr<Message>>>(); auto future = promise->get_future(); receives_[streamId] = promise; if (!receiving_) { receiving_ = true; co_spawn(ioContext_, startReceiving(), asio::detached); } co_return co_await future; } asio::awaitable<void> send(std::unique_ptr<Message> message) { auto promise = std::make_shared<asio::experimental::promise<void>>(); auto future = promise->get_future(); sends_[message->id] = promise; if (!sending_) { sending_ = true; co_spawn(ioContext_, startSending(), asio::detached); } co_await future; co_return; } private: asio::io_context &ioContext_; asio::steady_timer receiveTimer_; asio::steady_timer sendTimer_; std::map<uint64_t, std::shared_ptr< asio::experimental::promise<std::unique_ptr<Message>>>> receives_; std::map<uint64_t, std::shared_ptr<asio::experimental::promise<void>>> sends_; std::queue<std::unique_ptr<Message>> sendQueue_; bool receiving_ = false; bool sending_ = false; void completeSend(uint64_t messageId) { auto it = sends_.find(messageId); if (it != sends_.end()) { it->second->set_value(); // This resumes the send operation sends_.erase(it); // Clean up } } void completeReceive(std::unique_ptr<Message> message) { auto it = receives_.find(message->streamId); if (it != receives_.end()) { it->second->set_value( std::move(message)); // This resumes the send operation sends_.erase(it); // Clean up } } asio::awaitable<void> startReceiving() { while (!receives_.empty()) { // Simulate receiving a message sendTimer_.expires_after(std::chrono::seconds(1)); co_await sendTimer_.async_wait(asio::use_awaitable); auto message = std::make_unique<Message>(); message->id = 1; message->streamId = 1; message->priority = 1; completeReceive(std::move(message)); } receiving_ = false; co_return; } asio::awaitable<void> startSending() { while (!sends_.empty()) { sendTimer_.expires_after(std::chrono::seconds(1)); auto message = std::move(sendQueue_.front()); sendQueue_.pop(); co_await sendTimer_.async_wait(asio::use_awaitable); completeSend(message->id); } sending_ = false; co_return; } }; class Stream { public: Stream(std::shared_ptr<NetworkConnection> connection) : connection_(std::move(connection)) {} asio::awaitable<std::unique_ptr<Message>> receive() { co_return co_await connection_->receive(id_); } asio::awaitable<void> send(std::unique_ptr<Message> message) { message->streamId = id_; co_return co_await connection_->send(std::move(message)); } private: uint64_t id_; std::shared_ptr<NetworkConnection> connection_; };

2 1

Re: [Boost-users] [beast] I can't write a hello world server
by Mohammad Nejati [ashtum] 08 Apr '24

08 Apr '24

> Then I wait almost 4 seconds for a successful compilation. `-O2` and `-Og -g` are worse at 6 seconds. You are right, Asio and Asio based libraries are usually heavily templated as they need to work with generic executors, buffers and stream types. There are new facilities in Asio for alleviating this issue like any_executor and any_completion_handler which you can utilize to implement async operations in a source file. > I figured I'd write a wrapper, that would confine boost/asio/beast includes to a single compilation unit. The API I'm aiming for looks like this I think you might just use `beast::http::request<string_body>` and `beast::http::response<string_body>` types, you don't need to include all header files, you can just include `boost/beast/http/message.hpp`. > And yet I can sense a potential problem right off the bat: in the `http_server()` function, we call `std::move(socket)`. This move seems to be mandatory here, because removing triggers a compilation error. My point is, it looks like upon incoming connection we move the socket out of its outer context, such that it is no longer bound to the IO context. Is this another error in the example? You don't need to pass a socket to acceptor, it has multiple overloads: https://www.boost.org/doc/libs/1_84_0/doc/html/boost_asio/reference/basic_s… One of them creates a socket and passes it to the completion token, so, you can use it like: acceptor.async_accept([](auto ec, auto socket){ // ... }); Regards, Mohammad On Thu, Apr 4, 2024 at 4:50 PM Loup VAILLANT via Boost-users <boost-users(a)lists.boost.org> wrote: > > Hello, > > So this is rather embarrassing. After working more than 2 days full time I can't even get the most basic code running. I've scoured the docs and tried to find some tutorial, no luck. My onboarding experience so far has been… less than perfect. > > The reason I'm taking the time to ask here is because I feel there is something fundamental, likely obvious to the experts, that I don't understand about how beast (and, I'm guessing, asio) works, and how I'm supposed to use it. Which is probably why seemingly innocuous changes to official example code are causing memory corruptions left and right. > > Let's start at the beginning. > > My first attempt with beast was getting this code to work: > https://www.boost.org/doc/libs/1_73_0/libs/beast/example/http/server/small/… > > Compiling it with `g++ -std=c++20`, gets me a compilation error, thankfully easily fixed. > Then I wait almost 4 seconds for a successful compilation. `-O2` and `-Og -g` are worse at 6 seconds. > > I know many developers would say a few seconds are no big deal (though wen we get to XKCD sword fights it kind of is), but my problem here is that I didn't want to wait every time I made a business logic change to my code. But since 95% of compilation time came from including a huge header-only library, I figured I'd write a wrapper, that would confine boost/asio/beast includes to a single compilation unit. The API I'm aiming for looks like this: > > struct Http_message { > std::unordered_map<std::string, std::string> headers; > std::string body; > }; > struct Http_request : public Http_message { > std::string method; > std::string target; > }; > struct Http_response : public Http_message { > int status; > }; > typedef std::function<Http_response(const Http_request &request)> response_cb; > void http_start(unsigned short port, response_cb on_respond); > > (Note 1: I want web sockets as well, but one problem at a time) > (Note 2: I tried wrapping around http::request and http::response more directly to avoid unnecessary copies, but I ran into lifetime issues.) > > To its credit, this small server example seemed to run well enough, and could serve as a starting point. Before I untangle the business code from the HTTP specific stuff though, I needed to simplify this example a bit. So *this* is my actual starting point: > > > #include <boost/beast/core.hpp> > #include <boost/beast/http.hpp> > > namespace beast = boost::beast; > namespace http = beast::http; > namespace net = boost::asio; > using tcp = boost::asio::ip::tcp; > > class http_connection : public std::enable_shared_from_this<http_connection> > { > public: > http_connection(tcp::socket socket) : socket_(std::move(socket)){} > > void start() > { > auto self = shared_from_this(); > http::async_read( > socket_, buffer_, request_, > [self](beast::error_code ec, std::size_t) { > if(!ec) { self->process_request(); } > }); > deadline_.async_wait( > [self](beast::error_code ec) { > if(!ec) { self->socket_.close(ec); } > }); > } > > private: > tcp::socket socket_; > beast::flat_buffer buffer_{8192}; > http::request <http::dynamic_body> request_; > http::response<http::dynamic_body> response_; > net::steady_timer deadline_ { > socket_.get_executor(), std::chrono::seconds(60) }; > > void process_request() { > response_.version(request_.version()); > response_.keep_alive(false); > response_.result(http::status::ok); > response_.set(http::field::server, "Beast"); > response_.set(http::field::content_type, "text/plain"); > beast::ostream(response_.body()) > << "Target = " << request_.target() << "\n" > << "Method = " << std::string(request_.method_string()) << "\n"; > response_.set(http::field::content_length, > std::to_string(response_.body().size())); > > auto self = shared_from_this(); > http::async_write( > socket_, response_, > [self](beast::error_code ec, std::size_t) { > self->socket_.shutdown(tcp::socket::shutdown_send, ec); > self->deadline_.cancel(); > }); > } > }; > > void http_server(tcp::acceptor& acceptor, tcp::socket& socket) > { > auto cb = [&](beast::error_code ec) { > if(!ec) {std::make_shared<http_connection>(std::move(socket))->start();} > http_server(acceptor, socket); > }; > acceptor.async_accept(socket, cb); > } > > int main(void) > { > auto const address = net::ip::make_address("0.0.0.0"); > unsigned short port = 8080; > net::io_context ioc {1}; > tcp::acceptor acceptor{ioc, {address, port}}; > tcp::socket socket {ioc}; > http_server(acceptor, socket); > ioc.run(); > return 0; > } > > > So far it works. It listens to port 8080, and a curl request or 3 to the server works as expected: > > > $ curl -XYOLO -v http://localhost:8080/foobar > * Trying 127.0.0.1:8080... > * Connected to localhost (127.0.0.1) port 8080 (#0) > > YOLO /foobar HTTP/1.1 > > Host: localhost:8080 > > User-Agent: curl/7.81.0 > > Accept: */* > > > * Mark bundle as not supporting multiuse > < HTTP/1.1 200 OK > < Connection: close > < Server: Beast > < Content-Type: text/plain > < Content-Length: 31 > < > Target = /foobar > Method = YOLO > * Closing connection 0 > > And yet I can sense a potential problem right off the bat: in the `http_server()` function, we call `std::move(socket)`. This move seems to be mandatory here, because removing triggers a compilation error. My point is, it looks like upon incoming connection we move the socket out of its outer context, such that it is no longer bound to the IO context. Is this another error in the example? > > Okay then, how about I pass the socket all the way by reference instead? Let the constructor get a `tcp::socket&`, store this in a `tcp::socket&` member variable, remove all the `std::move`. It compiles, it runs the first query, but at the second query my program just freezes. Or loops, I don't know. > > So that's the first thing. I am _really confused_ about how this socket is supposed to work. Why does it block when I remove the standard moves? Isn't it supposed to be the same socket bound to the same IO context all the way? And I don't think it falls out of scope before the program ends either, it lives on the stack of the `main()` function, and the `ioc.run()`we call at the end blocks until we're done with the async reads (which is, never). > > **Can someone explain to me what the hell is going on with this socket?** > > Right now though I can accept that some dark secret lies behind this `std::move()`, and leave it alone for now. > > Moving on, I'll just admit for the time being that something magical and forbidden lies between this mysterious `std::move()` and prudently leave it behind. Now it's working again, and I can move (no pun intended) to the next step: extracting the business logic to an external function. I start with a trivial extraction: > > void respond(http::response<http::dynamic_body> &response, > const http::request <http::dynamic_body> &request) > { > response.result(http::status::ok); > response.set(http::field::content_type, "text/plain"); > beast::ostream(response.body()) > << "Target = " << request.target() << "\n" > << "Method = " << std::string(request.method_string()) << "\n"; > } > > And modify `process_request()` accordingly: > > void process_request() { > response_.version(request_.version()); > response_.keep_alive(false); > response_.set(http::field::server, "Beast"); > respond(response_, request_); > response_.set(http::field::content_length, > std::to_string(response_.body().size())); > > auto self = shared_from_this(); > http::async_write( > socket_, response_, > [self](beast::error_code ec, std::size_t) { > self->socket_.shutdown(tcp::socket::shutdown_send, ec); > self->deadline_.cancel(); > }); > } > > That works, but this is not quite enough: my goal here is to isolate my user code from the overly long compilation times imposed by this huge boost::beast. Maybe I can include the request & response headers without pulling in the kitchen sink with it, but I don't quite trust it. So let's wrap the `http::response` in some class so I can keep my headers nice and small: > > > class http_response { > public: > http_response(http::response<http::dynamic_body> &response) > : response_(response) {} > > void set_status(int status) { > response_.result(status); > } > void set_header(const std::string &title, > const std::string &value) { > response_.set(title, value); > } > void set_body(const std::string &body) { > beast::ostream(response_.body()) << body; > } > > private: > http::response<http::dynamic_body> &response_; > }; > > > Nothing fancy. And with a forward declaration I should be able to avoid including the response in the header that defines that class. Now I need to modify my business code accordingly: > > > void respond(http_response &response, > const http::request<http::dynamic_body> &request) > { > response.set_status(200); > response.set_header("Content-Type", "text/plain"); > response.set_body( > "Target = " + std::string(request.target()) + "\n" + > "Method = " + std::string(request.method_string()) + "\n"); > } > > > Still not free from `http::request <http::dynamic_body>` yet, but one step at a time. And finally, I need to adjust `process_request()`: > > void process_request() { > response_.version(request_.version()); > response_.keep_alive(false); > response_.set(http::field::server, "Beast"); > http_response response(response_); > respond(response, request_); > response_.set(http::field::content_length, > std::to_string(response_.body().size())); > > auto self = shared_from_this(); > http::async_write( > socket_, response_, > [self](beast::error_code ec, std::size_t) { > self->socket_.shutdown(tcp::socket::shutdown_send, ec); > self->deadline_.cancel(); > }); > } > > > Huh, what do you know, this time around it worked. I no longer experience the lifetime issues I've once had. Okay, I guess I'll add the request wrapper, then: > > > class http_request { > public: > http_request(const http::request<http::dynamic_body> &request) > : request_(request) {} > > std::string target() const { return std::string(request_.target()); } > std::string method() const { return std::string(request_.method_string()); } > > private: > const http::request<http::dynamic_body> &request_; > }; > > void respond(http_response &response, const http_request &request) > { > response.set_status(200); > response.set_header("Content-Type", "text/plain"); > response.set_body( > "Target = " + request.target() + "\n" + > "Method = " + request.method() + "\n"); > } > > void process_request() { > response_.version(request_.version()); > response_.keep_alive(false); > response_.set(http::field::server, "Beast"); > http_response response(response_); > http_request request (request_); > respond(response, request); > response_.set(http::field::content_length, > std::to_string(response_.body().size())); > > auto self = shared_from_this(); > http::async_write( > socket_, response_, > [self](beast::error_code ec, std::size_t) { > self->socket_.shutdown(tcp::socket::shutdown_send, ec); > self->deadline_.cancel(); > }); > } > > > And it still works! Maybe it'll work out in the end? > Regardless, thanks for the rubber ducking I guess. > > My first question remains though: what the hell is going on with the socket? Why can't I just pass a reference along? Why do we even need a move constructor? Is there some special semantics, or `boost::asio` specific arcane, I should be privy to? > > Loup. > > _______________________________________________ > Boost-users mailing list > Boost-users(a)lists.boost.org > https://lists.boost.org/mailman/listinfo.cgi/boost-users

2 1

[release] Boost 1.85.0 beta 1 is available
by Marshall Clow 14 Mar '24

14 Mar '24

Boost release 1.85.0 beta 1 is now available at: https://boostorg.jfrog.io/artifactory/main/beta/1.85.0.beta1/source/ The SHA256 checksums are: c13b76f420684a8d5b2eb0f297c281348ba0311d50354d952c5ce7c689e7879b boost_1_85_0_b1.zip e65d529023c7b08d0b92c53fff24ce9df9568cc0fe667c90caf8a9dbc5e63b0d boost_1_85_0_b1.7z 9c1ce4793342e8e57eb34c61f774a9dac0c6fc036084785e416613a18091bacc boost_1_85_0_b1.tar.gz cf7449faedeac9b76bade8ee59007cc4456a14de375dfcbd9e6e38aabe8a1334 boost_1_85_0_b1.tar.bz2 There was one problem reported during the beta release process; when you build the release using b2, it will emit a warning: [errno 2] failed to scan file '': No such file or directory This is harmless, and will be fixed for the final release. the release notes are available at: https://www.boost.org/users/history/version_1_85_0.html Please try the beta and report any problems you encounter. Thanks to everyone who contributed to the release. -- Boost Release Team

2 1

Can SIMD in boost unordered be disabled without disabling SIMD for full compile.
by Ivan Matek 12 Mar '24

12 Mar '24

Hi, I have some small maps where I am pretty sure SIMD tricks that are amazing in general will just slow down the lookups since I never lookup items not in the map and map is so small that benefits of not looking up into the big array and trashing the cache are miniscule. I know I can force compiler to not support SIMD with march, but I want to keep the SIMD optimizaitons for rest of the code, including large boost unordered objects. If you do not believe me I can write a custom benchmark, from what I see all benchmarks in docs start at 1E+4. P.S. I know I can just use an array, but I am in that "size range" where iteration becomes slower than a hash map. regards, Ivan

2 2

Re: [Boost-users] Hi all,
by Pavel Vazharov 06 Mar '24

06 Mar '24

Hi, The most obvious error that I see is that you use `std::vector<char> buffer_data(1024);`as local variables and then they are destroyed but you continue to keep references to them via the boost::asio::buffer. The latter will not keep the `std::vector`s alive. You need to keep the std::vector as a member variable and only when you call the asio functions use the `boost::asio::buffer` function. Like m_socketHandler->socket.async_read_some(boost::asio::buffer(m_buffer_data), ... Where the m_buffer_data is a member variable of type `std::vector<char>`. HTH, Pavel.

1 0

Hi all,
by Maria Tirindelli 06 Mar '24

06 Mar '24

I am experiencing an issue with boost 1.74 on linux. I am trying to have a server that asynchronously reads data from a tcp socket, and then closes when the client disconnect. My code looks like: class SimpleTCPServerTest::SocketHandler { public: explicit SocketHandler(boost::asio::ip::tcp::socket inputSocket ) : socket(std::move(inputSocket)) { socket.set_option(boost::asio::socket_base::keep_alive(true)); } boost::asio::ip::tcp::socket socket; }; SimpleTCPServerTest::SimpleTCPServerTest(std::string address, int port) : m_address(std::move(address)), m_port(port), m_ioc(boost::asio::io_context(1)), m_acceptor(boost::asio::ip::tcp::acceptor(m_ioc)), readTimer(m_ioc){ std::vector<char> buffer_data(1024); this->m_buffer = boost::asio::buffer(buffer_data); } bool SimpleTCPServerTest::open() { //auto const address = boost::asio::ip::make_address(ip); boost::asio::ip::tcp::endpoint endpoint(boost::asio::ip::tcp::v4(), static_cast<unsigned short>(m_port)); boost::system::error_code ec; // Open the acceptor m_acceptor.open(endpoint.protocol(), ec); if (ec) { LOG_ERROR("SimpleTCPServerTest", "Failed to open acceptor: " << ec.message()); return false; } // Allow address reuse m_acceptor.set_option(boost::asio::socket_base::reuse_address(true), ec); if (ec) { LOG_ERROR("SimpleTCPServerTest", "Failed to set reuse option in acceptor: " << ec.message()); return false; } // Bind to the server address m_acceptor.bind(endpoint, ec); if (ec) { LOG_ERROR("SimpleTCPServerTest", "Failed to bind acceptor: " << ec.message()); return false; } // Start listening for connections m_acceptor.listen(boost::asio::socket_base::max_listen_connections, ec); if (ec) { LOG_ERROR("SimpleTCPServerTest", "acceptor failed to start listening: " << ec.message()); return false; } m_acceptor.async_accept(boost::asio::make_strand(m_ioc), [this](boost::system::error_code ec, boost::asio::ip::tcp::socket socket) { on_accept(ec, std::move(socket)); }); m_iocRunThread = boost::thread([this] { m_ioc.run(); LOG_INFO("Exiting run thread"); }); return true; } } void SimpleTCPServerTest::on_accept(boost::system::error_code ec, boost::asio::ip::tcp::socket socket) { LOG_INFO("Client is connected"); m_socketHandler = std::make_unique<SocketHandler>(std::move(socket)); read(); } void SimpleTCPServerTest::read() { LOG_INFO("SimpleTCPServerTest", "Waiting a new message"); readTimer.expires_from_now(boost::posix_time::milliseconds(50)); readTimer.async_wait([this](boost::system::error_code ec) { LOG_INFO("Timer expired"); if (ec != boost::asio::error::operation_aborted) return; LOG_INFO("Timer expired with error"); m_socketHandler->socket.cancel(); }); m_socketHandler->socket.async_read_some(m_buffer, [this](const boost::system::error_code error, // Result of operation. std::size_t bytes_transferred) { if (error) { LOG_INFO("Client disconnected: " << error.message()); signalReadyToStop.emitSignal(); // HERE IT CRASHES return; } std::string dataString(boost::asio::buffer_cast<const char*>(m_buffer), bytes_transferred); LOG_INFO("Data was received: Size: " << bytes_transferred << " " << dataString); // Reset the buffer std::vector<char> buffer_data(1024); this->m_buffer = boost::asio::buffer(buffer_data); this->read(); }); } SimpleTCPServerTest::~SimpleTCPServerTest() { LOG_INFO("Terminating"); readTimer.cancel(); m_acceptor.cancel(); m_socketHandler->socket.cancel(); m_ioc.stop(); m_iocRunThread.join(); } The client is a simple python client that sends a few messages before disconnecting. my main.cpp is like: std::atomic<bool> m_runFlag = true; SimpleTCPServerTest server; server.signalReadyToStop.connect([&m_runFlag](){ m_runFlag =false; }); server.open(); while(m_runFlag) { std::this_thread::sleep_for(std::chrono::milliseconds(1000)); } LOG_INFO("Exiting test"); } The problem is that the code always crashes when returning from the async_read (indicated with "HERE IT CRASHES COMMENT") with error SIGABRT tcache_thread_shutdown(): unaligned tcache chunk detected. Even if I remove the return statement there, I still have the crash when calling m_ioc.stop(). It seems the error occurs when exiting from the m_iocRunThread (the "Exiting run thread" log is executed) What am I doing wrong? Thanks everyone

1 0

tommath.h and boost\multiprecision\tommath.hpp
by Helmut Zeisel 28 Feb '24

28 Feb '24

I tried to use boost muiltiprecision with Visual Studio 2022, 64 bit and got the following error message: boost\multiprecision\tommath.hpp(444,36): error C2664: 'mp_err mp_radix_size(const mp_int *,int,size_t *)': cannot convert argument 3 from 'int *' to 'size_t *' I used tommath.h from https://github.com/libtom/libtommath/blob/develop/tommath.h that has (line 583) mp_err mp_radix_size(const mp_int *a, int radix, size_t *size) MP_WUR; but boost\multiprecision\tommath.hpp, lineS 443/444 are int s; detail::check_tommath_result(mp_radix_size(const_cast< ::mp_int*>(&m_data), base, &s)); I compared with cygwin, there tommath.h is mp_err mp_radix_size(const mp_int *a, int radix, int *size) MP_WUR; So I am not sure: do I need some different tommath for Visual Studio 2022, 64 bit, or should boost\multiprecision\tommath.hpp be changed? Helmut

2 3

boost::stacktrace::stacktrace AND addr2line
by Foelsche, Peter 19 Feb '24

19 Feb '24

Dear All, Thanks for outstanding quality of boost! I'm using the stacktrace object together with debug info and BOOST_STACKTRACE_USE_ADDR2LINE defined. Would it be possible to cache the output of addr2line assuming that during the lifetime of the calling process the queried executable or shared objects do not change? Thanks Peter

2 2

[boost::interprocess] between Rosetta and native apps - please advice how to fix issue
by Frank G 07 Feb '24

07 Feb '24

We need named IPC between Rosetta and native apps. In boost this seems not compatible, for example with Native app and we are unable to find the "MAP_FNAME" in find_and_construct on the Rosetta process. Works fine when each process is on same arch. " typedef boost::interprocess::managed_shared_memory shared_mem;shared_mem* seg;seg = new shared_mem(boost::interprocess::open_or_create, SHARED_FILENAME, F_MAX_TOTALBUF_SIZE );Img = seg->find_or_construct<imgtype>(MAP_FNAME)(); " Root cause seems to be MemoryAlgorithm and alignment.This has alignment of 16 for Rosetta and 8 for native.The 8 byte shift seems to be the root cause and I can see this when viewing memory. Looking deeper over the last few days we can see this from the difference in frontend size (from MemoryAlgorithm): "boost::interprocess::open_or_create This creates different sized frontend (iset_index 8 or 16)for Native vs Rosetta. frontend is defined from: boost::interprocess::ipcdetail::basic_managed_memory_impl<char, boost::interprocess::rbtree_best_fit<boost::interprocess::mutex_family>, boost::interprocess::iset_index, 16> *const Then perform segment->find_or_construct<mtstruct>(MAP_FNAME)(); does not work across arch." Ideally we prefer not to write a bunch of complex custom allocators etc to get this to work with open_or_create and find_or_construct, and hoping there is some simplest solution. Questions: how can we workaround this? Can we force boost::interprocess::open_or_create to use same memory algo for both arch? Or force alignment to 16 for both arch?

1 0