使用boost.process同时读取和写入孩子的STDIO
simultaneous read and write to child's stdio using boost.process
我正在尝试使用boost.process使用如下所示的内容写入和读取孩子的stdio：
boost::asio::io_service writeService, readService;
bp::async_pipe in{writeService};
bp::async_pipe out{readService};
bp::child process(CompressCmd.c_str(), bp::std_in < in, bp::std_out > out);
Buffer src;
src.reserve(4 * 1024 * 1024);
integer_type read = 0;
//std::atomic_int64_t totalWrite{0};
integer_type totalWrite = 0;
while (callback(CallbackActions::NeedMoreInput, src, read)) {
in.async_write_some(
boost::asio::buffer(src.data(), read),
[](const boost::system::error_code &e, std::size_t) { });
// written data is not important, that's why using same buffer
out.async_read_some(boost::asio::buffer(src.data(), src.capacity()),
[&](const boost::system::error_code &e,
std::size_t byte_transferred) { totalWrite += byte_transferred; });
}
writeService.run();
in.close();
readService.run();
所有读取和写入操作都被标记为成功，但 totalWrite 的值完全不正确 f.e 报告29356032，实际值应该在 50000000 左右
我注意到程序中途终止，在readService.run()冻结孩子后使用process.wait()，使用原子int产生相同的行为
，现在我实际上只需要知道实际有多少数据，
这就是为什么我使用相同的缓冲区
-
此模式：
while (callback(CallbackActions::NeedMoreInput, src, read)) { in.async_write_some(...); out.async_read_some(...); }很可能被误导了(异步操作总是立即返回，因此您只需继续添加更多异步操作而不给它们运行的机会)。
-
同样被误导的是，您有单独的管道服务，但您在完全排除的情况下运行它们，因此在 writeService 完成之前不会运行任何读取操作。
-
atomic类型被误导，因为无法从多个线程进行访问 -
你想做什么？您保留了一个很大的缓冲区，但从不将任何数据放入其中(
reserve！=resize)。因此，您只能希望什么都不写。更具讽刺意味的是，你正在完全相同的缓冲区中读取，在完全相同的位置。但是，这立即是未定义的行为¹，因为当您知道该
src.size()==0时，您会src.capacity()传递它。即使没有该错误，您如何"同时"从内存中完全相同的字节读取和写入，并且仍然知道预期的结果是什么？
-
您没有将自己的
io_service传递给提升过程
工作演示
下面是一个工作示例。当然，我必须猜测你到底想做什么。
我选择让程序将自己的源代码(main.cpp)发送到stdin，并迭代读取stdout，记录total_received字节。然后，它会打印退出代码和总计。
作为临时压缩机，我使用了'/usr/bin/xxd'，因为它可用，甚至可以有效地打印到std::cout进行调试。
住在科里鲁 //科里鲁的麻烦
#include <boost/asio.hpp>
#include <boost/process.hpp>
#include <boost/process/async.hpp>
#include <iostream>
std::vector<char> read_file(std::string const&);
namespace bp = boost::process;
using boost::system::error_code;
using Loop = boost::function<void()>;
using Buffer = std::array<char, 4*1024>;
int main() {
boost::asio::io_service svc;
std::string const CompressCmd = "/usr/bin/xxd";
bp::async_pipe in{svc}, out{svc};
bp::child process(CompressCmd, bp::std_in < in, bp::std_out > out, svc);
auto data = read_file("main.cpp");
Loop read_loop, write_loop;
Buffer recv_buffer;
std::size_t total_received = 0;
read_loop = [&read_loop, &out, &recv_buffer, &total_received] {
out.async_read_some(boost::asio::buffer(recv_buffer),
[&](error_code ec, size_t transferred) {
std::cout << "ReadLoop: " << ec.message() << " got " << transferred << " bytesn";
total_received += transferred;
if (!ec)
read_loop(); // continue reading
});
};
boost::asio::async_write(in, boost::asio::buffer(data),
[&](error_code ec, size_t transferred) {
std::cout << "WriteLoop: " << ec.message() << " done, " << transferred << " bytesn";
in.close(ec);
std::cout << "WriteLoop: closed pipe (" << ec.message() << ")n";
}); // async
read_loop(); // async
svc.run(); // Await all async operations
std::cout << "Process exitcode " << process.exit_code() << ", total_received=" << total_received << "n";
}
#include <fstream>
#include <iterator>
std::vector<char> read_file(std::string const& fname) {
std::ifstream ifs(fname);
return {std::istreambuf_iterator<char>(ifs), {}};
}
印刷
WriteLoop: Success done, 1787 bytes
WriteLoop: closed pipe (Success)
ReadLoop: Success got 4096 bytes
ReadLoop: Success got 3515 bytes
ReadLoop: End of file got 0 bytes
Process exitcode 0, total_received=7611
解释，简化
请注意，我们在没有循环的情况下完成所有写作。这是因为boost::asio::async_write是一个组合操作(它隐藏了循环)。
同样，如果您可以"负担得起"将整个接收数据存储在内存中，则可以通过使用boost::asio::streambuf和使用类似的组合操作来简化：
住在科里鲁//科里鲁的麻烦
#include <boost/asio.hpp>
#include <boost/process.hpp>
#include <boost/process/async.hpp>
#include <iostream>
std::vector<char> read_file(std::string const&);
namespace bp = boost::process;
using boost::system::error_code;
int main() {
boost::asio::io_service svc;
std::string const CompressCmd = "/usr/bin/xxd";
bp::async_pipe in{svc}, out{svc};
bp::child process(CompressCmd, bp::std_in < in, bp::std_out > out, svc);
auto data = read_file("main.cpp");
boost::asio::streambuf recv_buffer;
boost::asio::async_read(out, recv_buffer,
[&](error_code ec, size_t transferred) {
std::cout << "ReadLoop: " << ec.message() << " got " << transferred << " bytesn";
});
boost::asio::async_write(in, boost::asio::buffer(data),
[&](error_code ec, size_t transferred) {
std::cout << "WriteLoop: " << ec.message() << " done, " << transferred << " bytesn";
in.close(ec);
std::cout << "WriteLoop: closed pipe (" << ec.message() << ")n";
}); // async
svc.run(); // Await all async operations
std::cout << "Process exitcode " << process.exit_code() << ", total_received=" << recv_buffer.size() << "n";
}
#include <fstream>
#include <iterator>
std::vector<char> read_file(std::string const& fname) {
std::ifstream ifs(fname);
return {std::istreambuf_iterator<char>(ifs), {}};
}
相反，如果您负担不起在发送之前将所有数据都放在内存中，则可以创建一个循环来逐块发送输入
两个异步环路，有延迟
让我们这样做，通过在编写每个块之前延迟一秒钟来使其更具娱乐性。您希望看到的是由于延迟而发生的交替读取/写入：
住在科里鲁//耶在科里鲁上运行
#include <boost/asio.hpp>
#include <boost/asio/high_resolution_timer.hpp>
#include <boost/process.hpp>
#include <boost/process/async.hpp>
#include <iostream>
#include <fstream>
namespace bp = boost::process;
using boost::system::error_code;
using namespace std::chrono_literals;
using Loop = boost::function<void()>;
using Buffer = std::array<char, 500>;
int main() {
boost::asio::io_service svc;
auto on_exit = [](int code, std::error_code ec) {
std::cout << "Exited " << code << " (" << ec.message() << ")n";
};
std::string const CompressCmd = "/usr/bin/xxd";
bp::async_pipe in{svc}, out{svc};
bp::child process(CompressCmd, bp::std_in < in, bp::std_out > out, svc, bp::on_exit(on_exit));
Loop read_loop, write_loop;
Buffer recv_buffer;
std::size_t total_received = 0;
read_loop = [&read_loop, &out, &recv_buffer, &total_received] {
out.async_read_some(boost::asio::buffer(recv_buffer),
[&](error_code ec, size_t transferred) {
std::cout << "ReadLoop: " << ec.message() << " got " << transferred << " bytesn";
total_received += transferred;
if (!ec)
read_loop(); // continue reading
});
};
std::ifstream ifs("main.cpp");
std::size_t total_written = 0;
Buffer send_buffer;
boost::asio::high_resolution_timer send_delay(svc);
write_loop = [&write_loop, &in, &ifs, &send_buffer, &total_written, &send_delay] {
if (!ifs.good())
{
error_code ec;
in.close(ec);
std::cout << "WriteLoop: closed stdin (" << ec.message() << ")n";
return;
}
ifs.read(send_buffer.data(), send_buffer.size());
boost::asio::async_write(in, boost::asio::buffer(send_buffer.data(), ifs.gcount()),
[&](error_code ec, size_t transferred) {
std::cout << "WriteLoop: " << ec.message() << " sent " << transferred << " bytesn";
total_written += transferred;
if (!ec) {
send_delay.expires_from_now(1s);
send_delay.async_wait([&write_loop](error_code ec) {
std::cout << "WriteLoop: send delay " << ec.message() << "n";
if (!ec) write_loop(); // continue writing
});
}
});
};
read_loop(); // async
write_loop(); // async
svc.run(); // Await all async operations
std::cout << "Process exitcode " << process.exit_code() << ", total_received=" << total_received << "n";
}
指纹
WriteLoop: Success sent 500 bytes
WriteLoop: send delay Success
WriteLoop: Success sent 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 96 bytes
WriteLoop: send delay Success
WriteLoop: Success sent 500 bytes
WriteLoop: send delay Success
WriteLoop: Success sent 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 96 bytes
WriteLoop: send delay Success
WriteLoop: Success sent 500 bytes
WriteLoop: send delay Success
WriteLoop: Success sent 134 bytes
WriteLoop: send delay Success
WriteLoop: closed stdin (Success)
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 500 bytes
ReadLoop: Success got 22 bytes
Exited 0 (Success)
ReadLoop: End of file got 0 bytes
Process exitcode 0, total_received=11214
¹ 也许只是未指定，我现在不倾向于找出区别
相关文章：
- 与 stdio 同步是否使程序 I/O 非交互式?
- 更改"child's parent's style sheet"时如何将孩子的样式表重置为 Qt 默认样式表？
- 为什么 isVisible 在 QWidget 孩子中不起作用
- 从macOS Catalina上的源代码编译LLVM(如何解决未找到"stdio.h")
- OOP使用不同的结构与孩子一起构建建议
- 从 stdio 获取一行空格分隔的整数，而不知道它们是多少 (C++）
- 未知C++错误:致命错误:glibc检测到无效的stdio句柄
- 使用 stdio.h 重新定位和重命名文件C++
- c ++如何将模板应用于模板类的孩子/朋友?
- 对应于 stdio.h 的库文件是动态链接还是静态链接
- 如何防止父进程在孩子死后丢失控制台输入?
- 我可以制作一个基于孩子具有不同回报的虚函数吗?
- C 从子线中杀死所有父母的孩子
- 如何替换/忽略 C stdio.h getline(） 中的无效 Unicode/UTF8 字符
- 为什么父母的方法在孩子被摧毁后仍然存在
- 有没有办法按类名找到 QObject 孩子?
- 如何在树上像孩子一样使用unique_ptr
- 破坏的父母和孩子的顺序
- 如果是双重注册，如何从Boost树中删除孩子
- 使用boost.process同时读取和写入孩子的STDIO
