Цитата(borisbn @ 11.4.2011, 12:44  ) | | Думаю, что сама отправка (скорость передачи по каналу) будет на порядки дольше, чем обращение к менеджеру памяти и копирование из одной области памяти в другую. |
тут Вы ошибаетесь.
в http://forum.vingrad.ru/forum/topic-325353/view-all.html теме, возьмите последние исходники и посмотрите. там очень простой код. выделение 13 байт, sprintf(), передача в async_write(), в хэндлере delete[]. ничего сложного ведь ;) но на 100мбитной сети, происходит 220000-250000 таких последовательностей, что полносьтю загружает одно ядро. вроде бы казалось, ничего сложного в этих операциях нет. но профайлер говорит что 48 процентов времени уходит только на new!
в общем, выделение памяти и инициализацию смарт_поинтера оставил на юзера. помоему, очень даже юзабельно получилось 
пожелания/рекомендации/критика приветствуются.
класс сокета:
| Код |
#ifndef _simple_socket_hpp_included_
#define _simple_socket_hpp_included_
#include <queue>
#include <stdexcept>
#include <iostream>
#include <boost/asio.hpp>
#include <boost/bind.hpp>
#include <boost/thread/mutex.hpp>
#include <boost/function.hpp>
#include <boost/shared_array.hpp>
#include <boost/system/error_code.hpp>
/***************************************************************************/
struct simple_socket: private boost::noncopyable {
typedef void(*read_handler_type)(const boost::system::error_code&, boost::shared_array<char>, size_t);
typedef void(*write_handler_type)(const boost::system::error_code&, boost::shared_array<char>, size_t);
simple_socket(boost::asio::io_service& ios)
:sock(ios),
write_in_process(false),
read_in_process(false)
{}
~simple_socket() {
clear_read_queue();
clear_write_queue();
disconnect();
}
boost::asio::ip::tcp::socket& socket() { return sock; }
void connect(const std::string& ip, boost::uint16_t port) {
sock.connect(
boost::asio::ip::tcp::endpoint(boost::asio::ip::address::from_string(ip), port)
);
}
void disconnect() {
if ( sock.is_open() ) {
sock.shutdown(boost::asio::ip::tcp::socket::shutdown_both);
sock.close();
}
}
size_t read_queue_size() const { return read_queue.size(); }
size_t write_queue_size() const { return write_queue.size(); }
void clear_read_queue() {
read_queue.clear();
if ( sock.is_open() ) sock.cancel();
}
void clear_write_queue() {
write_queue.clear();
if ( sock.is_open() ) sock.cancel();
}
template<typename F>
void async_write(boost::shared_array<char> arr, size_t size, F f) {
if ( !sock.is_open() ) throw std::runtime_error("socket is not connected");
if ( !arr.get() || !size ) return;
write_queue.push({f, arr, size});
if ( !write_in_process ) {
write_in_process = true;
write_exec();
}
}
void async_write(boost::shared_array<char> arr, size_t size, write_handler_type f) {
async_write(arr, size, boost::bind(f, _1, _2, _3));
}
template<typename Obj>
void async_write(boost::shared_array<char> arr,
size_t size,
Obj* obj,
void(Obj::*handler)(const boost::system::error_code&, boost::shared_array<char>, size_t))
{
async_write(arr, size, boost::bind(handler, obj, _1, _2, _3));
}
template<typename F>
void async_read(size_t size, F f) {
if ( !sock.is_open() ) throw std::runtime_error("socket is not connected");
if ( !size ) return;
read_queue.push({f, boost::shared_array<char>(), size});
if ( !read_in_process ) {
read_in_process = true;
read_exec();
}
}
void async_read(size_t size, read_handler_type f) {
async_read(size, boost::bind(f, _1, _2, _3));
}
template<typename Obj>
void async_read(size_t size,
Obj* obj,
void(Obj::*handler)(const boost::system::error_code&, boost::shared_array<char>, size_t))
{
async_read(size, boost::bind(handler, obj, _1, _2, _3));
}
private:
typedef boost::function<void(const boost::system::error_code&, boost::shared_array<char>, size_t)> handler_type;
struct pair {
handler_type handler;
boost::shared_array<char> buf;
size_t size;
};
void write_exec() {
pair p = write_queue.pop();
boost::asio::async_write(
sock,
boost::asio::buffer(p.buf.get(), p.size),
boost::bind(
&simple_socket::write_exec_handler,
this,
p,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred
)
);
}
void write_exec_handler(pair p, const boost::system::error_code& e, size_t wr) {
p.handler(e, p.buf, wr);
if ( !write_queue.empty() ) {
write_exec();
} else {
write_in_process = false;
}
}
void read_exec() {
pair p = read_queue.pop();
p.buf.reset(new char[p.size]);
boost::asio::async_read(
sock,
boost::asio::buffer(p.buf.get(), p.size),
boost::bind(
&simple_socket::read_exec_handler,
this,
p,
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred
)
);
}
void read_exec_handler(pair p, const boost::system::error_code& e, size_t rd) {
p.handler(e, p.buf, rd);
if ( !read_queue.empty() ) {
read_exec();
} else {
read_in_process = false;
}
}
private:
template<typename T>
struct queue {
void push(T p) {
boost::mutex::scoped_lock locker(mutex);
queue.push(p);
}
T pop() {
boost::mutex::scoped_lock locker(mutex);
if ( queue.empty() ) {
throw std::runtime_error("queue is empty");
}
T p = queue.front();
queue.pop();
return p;
}
void clear() {
boost::mutex::scoped_lock locker(mutex);
while ( !queue.empty() ) {
queue.pop();
}
}
bool empty() const {
boost::mutex::scoped_lock locker(mutex);
return queue.empty();
}
size_t size() const {
boost::mutex::scoped_lock locker(mutex);
return queue.size();
}
private:
mutable boost::mutex mutex;
std::queue<T> queue;
};
boost::asio::ip::tcp::socket sock;
queue<pair> write_queue;
bool write_in_process;
queue<pair> read_queue;
bool read_in_process;
};
/***************************************************************************/
#endif // _simple_socket_hpp_included_
|
пример 1:
| Код |
#include "simple_socket.hpp"
#include <iostream>
/***************************************************************************/
void write_handler(const boost::system::error_code& e, boost::shared_array<char> arr, size_t wr) {
fprintf(stdout, "write_handler(): %s, %d, e = %s\n", arr.get(), wr, e.message().c_str());
fflush(stdout);
}
void read_handler(const boost::system::error_code& e, boost::shared_array<char> arr, size_t rd) {
fprintf(stdout, "read_handler(): %s, %d, e = %s\n", arr.get(), rd, e.message().c_str());
fflush(stdout);
}
/***************************************************************************/
int main() {
enum {
array_size = 32,
count = 1024
};
boost::asio::io_service ios;
simple_socket socket(ios);
try {
socket.connect("127.0.0.1", 44550);
for(int idx = 0; idx < count; ++idx) {
boost::shared_array<char> arr(new char[array_size]);
sprintf(arr.get(), "item: %d", idx);
socket.async_write(arr, array_size, &write_handler);
}
for(int idx = 0; idx < count; ++idx) {
socket.async_read(array_size, &read_handler);
}
ios.run();
socket.disconnect();
}
catch(const std::exception& e) {
std::cout << "[exception] " << e.what() << std::endl;
}
}
/***************************************************************************/
|
пример 2:
| Код |
#include "simple_socket.hpp"
#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
/***************************************************************************/
struct client_impl {
client_impl(boost::asio::io_service& ios, const std::string& ip, boost::uint16_t port)
:socket(ios),
str("string data")
{
socket.connect(ip, port);
}
void write() {
const size_t len = strlen(str);
boost::shared_array<char> arr(new char[len]);
strcpy(arr.get(), str);
socket.async_write(arr, len, this, &client_impl::write_handler);
}
void read() {
socket.async_read(strlen(str), this, &client_impl::read_handler);
}
void write_handler(const boost::system::error_code& e, boost::shared_array<char> arr, size_t wr) {
fprintf(stdout, "write_handler(): %s, %d, e = %s\n", arr.get(), wr, e.message().c_str());
fflush(stdout);
}
void read_handler(const boost::system::error_code& e, boost::shared_array<char> arr, size_t rd) {
fprintf(stdout, "read_handler(): %s, %d, e = %s\n", arr.get(), rd, e.message().c_str());
fflush(stdout);
}
private:
simple_socket socket;
const char* str;
};
/***************************************************************************/
int main() {
boost::asio::io_service ios;
client_impl client(ios, "127.0.0.1", 44550);
try {
client.write();
client.read();
ios.run();
}
catch(const std::exception& e) {
std::cout << "[exception] " << e.what() << std::endl;
}
}
/***************************************************************************/
|
пример 3:
| Код |
#include "simple_socket.hpp"
#include <iostream>
#include <boost/asio.hpp>
#include <boost/thread.hpp>
/***************************************************************************/
struct client_impl {
void write_handler(const boost::system::error_code& e, boost::shared_array<char> arr, size_t wr) {
fprintf(stdout, "write_handler(): %s, %d, e = %s\n", arr.get(), wr, e.message().c_str());
fflush(stdout);
}
void read_handler(const boost::system::error_code& e, boost::shared_array<char> arr, size_t rd) {
fprintf(stdout, "read_handler(): %s, %d, e = %s\n", arr.get(), rd, e.message().c_str());
fflush(stdout);
}
};
/***************************************************************************/
int main() {
boost::asio::io_service ios;
simple_socket socket(ios);
client_impl client;
try {
socket.connect("127.0.0.1", 44550);
const size_t arr_size = 32;
boost::shared_array<char> arr(new char[arr_size]);
sprintf(arr.get(), "data string");
socket.async_write(arr, arr_size, &client, &client_impl::write_handler);
socket.async_read(arr_size, &client, &client_impl::read_handler);
ios.run();
}
catch(const std::exception& e) {
std::cout << "[exception] " << e.what() << std::endl;
}
}
/***************************************************************************/
|
всем спасибо
Добавлено через 6 минут и 9 секунд
| Цитата(mes @ 11.4.2011, 12:00 ) | | нельзя ли пример строчки которая Вас не устраивает, с указанием неугодных моментов ? |
не нравится постоянно писать байнд.
в добавок, если сигнатура не соответствует, или не соответствует кол-во плейсхолдеров, или их вовсе нет - то глядеть в 120 строк вывода об ошибке сомнительное удовольствие. |
