我正在为Windows编写串口软件。为了提高性能，我试图将例程转换为使用异步I / O.我有代码并且运行得相当好，但我是半初学者，我想进一步提高程序的性能。在程序的压力测试期间（即在高波特率下尽可能快地向/从端口发送突发数据），CPU负载变得非常高。
如果有人在Windows中有异步I / O和多线程的经验，我将不胜感激，看看我的程序。我有两个主要问题：
异步I / O是否正确实现？我在网上发现了一些相当可靠的来源，建议您可以将用户数据传递给回调函数，方法是在最后用自己的数据实现自己的OVERLAPPED结构。这似乎工作得很好，但它确实看起来有点“hackish”给我。此外，当我从同步/轮询转换为异步/回调时，程序的性能没有那么大提高，让我怀疑我做错了什么。
对FIFO数据缓冲区使用STL std :: deque是否合理？由于当前编写了程序，我只允许在必须处理之前一次接收1个字节的数据。因为我不知道我将收到多少数据，所以可能是无穷无尽的数量。我假设这个1字节一次在必须分配数据时会产生deque线后面的缓慢行为。而且我也不相信deque也是线程安全的（我应该吗？）。 如果使用STL deque不合理，是否有任何建议可以使用更好的数据类型？基于静态数组的循环环缓冲区？
对代码的任何其他反馈也是最受欢迎的。
实现了串行例程，以便我有一个名为“Comport”的父类，它处理所有与串行I / O相关的内容。从这个类我继承了另一个名为“ThreadedComport”的类，这是一个多线程版本。
ThreadedComport类（相关部分）
class ThreadedComport : public Comport
{
private:
HANDLE _hthread_port; /* thread handle */
HANDLE _hmutex_port; /* COM port access */
HANDLE _hmutex_send; /* send buffer access */
HANDLE _hmutex_rec; /* rec buffer access */
deque<uint8> _send_buf;
deque<uint8> _rec_buf;
uint16 _data_sent;
uint16 _data_received;
HANDLE _hevent_kill_thread;
HANDLE _hevent_open;
HANDLE _hevent_close;
HANDLE _hevent_write_done;
HANDLE _hevent_read_done;
HANDLE _hevent_ext_send; /* notifies external thread */
HANDLE _hevent_ext_receive; /* notifies external thread */
typedef struct
{
OVERLAPPED overlapped;
ThreadedComport* caller; /* add user data to struct */
} OVERLAPPED_overlap;
OVERLAPPED_overlap _send_overlapped;
OVERLAPPED_overlap _rec_overlapped;
uint8* _write_data;
uint8 _read_data;
DWORD _bytes_read;
static DWORD WINAPI _tranceiver_thread (LPVOID param);
void _send_data (void);
void _receive_data (void);
DWORD _wait_for_io (void);
static void WINAPI _send_callback (DWORD dwErrorCode,
DWORD dwNumberOfBytesTransfered,
LPOVERLAPPED lpOverlapped);
static void WINAPI _receive_callback (DWORD dwErrorCode,
DWORD dwNumberOfBytesTransfered,
LPOVERLAPPED lpOverlapped);
};
通过CreateThread（）创建的主线程例程：
DWORD WINAPI ThreadedComport::_tranceiver_thread (LPVOID param)
{
ThreadedComport* caller = (ThreadedComport*) param;
HANDLE handle_array [3] =
{
caller->_hevent_kill_thread, /* WAIT_OBJECT_0 */
caller->_hevent_open, /* WAIT_OBJECT_1 */
caller->_hevent_close /* WAIT_OBJECT_2 */
};
DWORD result;
do
{
/* wait for anything to happen */
result = WaitForMultipleObjects(3,
handle_array,
false, /* dont wait for all */
INFINITE);
if(result == WAIT_OBJECT_1 ) /* open? */
{
do /* while port is open, work */
{
caller->_send_data();
caller->_receive_data();
result = caller->_wait_for_io(); /* will wait for the same 3 as in handle_array above,
plus all read/write specific events */
} while (result != WAIT_OBJECT_0 && /* while not kill thread */
result != WAIT_OBJECT_2); /* while not close port */
}
else if(result == WAIT_OBJECT_2) /* close? */
{
; /* do nothing */
}
} while (result != WAIT_OBJECT_0); /* kill thread? */
return 0;
}
反过来调用以下三个函数：
void ThreadedComport::_send_data (void)
{
uint32 send_buf_size;
if(_send_buf.size() != 0) // anything to send?
{
WaitForSingleObject(_hmutex_port, INFINITE);
if(_is_open) // double-check port
{
bool result;
WaitForSingleObject(_hmutex_send, INFINITE);
_data_sent = 0;
send_buf_size = _send_buf.size();
if(send_buf_size > (uint32)_MAX_MESSAGE_LENGTH)
{
send_buf_size = _MAX_MESSAGE_LENGTH;
}
_write_data = new uint8 [send_buf_size];
for(uint32 i=0; i<send_buf_size; i++)
{
_write_data[i] = _send_buf.front();
_send_buf.pop_front();
}
_send_buf.clear();
ReleaseMutex(_hmutex_send);
result = WriteFileEx (_hcom, // handle to output file
(void*)_write_data, // pointer to input buffer
send_buf_size, // number of bytes to write
(LPOVERLAPPED)&_send_overlapped, // pointer to async. i/o data
(LPOVERLAPPED_COMPLETION_ROUTINE )&_send_callback);
SleepEx(INFINITE, true); // Allow callback to come
if(result == false)
{
// error handling here
}
} // if(_is_open)
ReleaseMutex(_hmutex_port);
}
else /* nothing to send */
{
SetEvent(_hevent_write_done); // Skip write
}
}
void ThreadedComport::_receive_data (void)
{
WaitForSingleObject(_hmutex_port, INFINITE);
if(_is_open)
{
BOOL result;
_bytes_read = 0;
result = ReadFileEx (_hcom, // handle to output file
(void*)&_read_data, // pointer to input buffer
1, // number of bytes to read
(OVERLAPPED*)&_rec_overlapped, // pointer to async. i/o data
(LPOVERLAPPED_COMPLETION_ROUTINE )&_receive_callback);
SleepEx(INFINITE, true); // Allow callback to come
if(result == FALSE)
{
DWORD last_error = GetLastError();
if(last_error == ERROR_OPERATION_ABORTED) // disconnected ?
{
close(); // close the port
}
}
}
ReleaseMutex(_hmutex_port);
}
DWORD ThreadedComport::_wait_for_io (void)
{
DWORD result;
bool is_write_done = false;
bool is_read_done = false;
HANDLE handle_array [5] =
{
_hevent_kill_thread,
_hevent_open,
_hevent_close,
_hevent_write_done,
_hevent_read_done
};
do /* COM port message pump running until sending / receiving is done */
{
result = WaitForMultipleObjects(5,
handle_array,
false, /* dont wait for all */
INFINITE);
if(result <= WAIT_OBJECT_2)
{
break; /* abort */
}
else if(result == WAIT_OBJECT_3) /* write done */
{
is_write_done = true;
SetEvent(_hevent_ext_send);
}
else if(result == WAIT_OBJECT_4) /* read done */
{
is_read_done = true;
if(_bytes_read > 0)
{
uint32 errors = 0;
WaitForSingleObject(_hmutex_rec, INFINITE);
_rec_buf.push_back((uint8)_read_data);
_data_received += _bytes_read;
while((uint16)_rec_buf.size() > _MAX_MESSAGE_LENGTH)
{
_rec_buf.pop_front();
}
ReleaseMutex(_hmutex_rec);
_bytes_read = 0;
ClearCommError(_hcom, &errors, NULL);
SetEvent(_hevent_ext_receive);
}
}
} while(!is_write_done || !is_read_done);
return result;
}
异步I / O回调函数：
void WINAPI ThreadedComport::_send_callback (DWORD dwErrorCode,
DWORD dwNumberOfBytesTransfered,
LPOVERLAPPED lpOverlapped)
{
ThreadedComport* _this = ((OVERLAPPED_overlap*)lpOverlapped)->caller;
if(dwErrorCode == 0) // no errors
{
if(dwNumberOfBytesTransfered > 0)
{
_this->_data_sent = dwNumberOfBytesTransfered;
}
}
delete [] _this->_write_data; /* always clean this up */
SetEvent(lpOverlapped->hEvent);
}
void WINAPI ThreadedComport::_receive_callback (DWORD dwErrorCode,
DWORD dwNumberOfBytesTransfered,
LPOVERLAPPED lpOverlapped)
{
if(dwErrorCode == 0) // no errors
{
if(dwNumberOfBytesTransfered > 0)
{
ThreadedComport* _this = ((OVERLAPPED_overlap*)lpOverlapped)->caller;
_this->_bytes_read = dwNumberOfBytesTransfered;
}
}
SetEvent(lpOverlapped->hEvent);
}
答案 0 :(得分：7)
第一个问题很简单。这种方法不是hackish;你拥有OVERLAPPED内存及其后的所有内容。 Raymond Chen最好地描述了这一点：http://blogs.msdn.com/b/oldnewthing/archive/2010/12/17/10106259.aspx
如果你在等待I / O完成时有更好的事情，你只会期望性能提升。如果您所做的只是SleepEx，那么您只会看到CPU％下降。线索名称为“重叠” - 它允许您重叠计算和I / O.
std::deque<unsigned char>可以处理FIFO数据而不会出现大问题。它可能会回收4KB块（通过大量分析确定的精确数字，全部为您完成）。
[编辑] 我进一步研究了你的代码，似乎代码不必要复杂。对于初学者来说，异步I / O的一个主要好处是你不需要所有的线程。线程允许您使用更多内核，但是您正在处理速度较慢的I / O设备。即使是单个核心就足够了，如果它不会花费所有时间等待。而这恰恰是I / O重叠的原因。您只需将一个线程专用于端口的所有I / O工作。由于它是唯一的线程，因此不需要互斥锁来访问该端口。
OTOH，你需要一个围绕deque<uint8>个对象的互斥锁，因为生产者/消费者线程与comport线程不同。
答案 1 :(得分：1)
我没有看到在这样的项目中使用异步I / O的任何原因。当您处理大量套接字或在等待数据时要做的工作时，异步I / O是很好的，但据我所知，您只处理单个套接字并且之间没有做任何工作
另外，仅为了解，您通常会使用I / O完成端口来处理异步I / O.我不确定是否存在使用I / O完成端口对性能产生负面影响的情况。
但是，您的异步I / O使用情况看起来还不错。实现自己的OVERLAPPED结构看起来像黑客，但它是正确的;没有其他方法可以将您自己的数据与完成相关联。
Boost也有一个循环缓冲区实现，虽然我不确定它是否是线程安全的。但是，没有一个标准库容器是线程安全的。
答案 2 :(得分：1)
我认为您的代码设计欠佳。
我猜你正在共享太多线程的太多数据结构。我认为您应该将一个端口的串行设备IO的所有处理放入一个线程，并在IO线程和所有客户端线程之间放置一个同步的命令/数据队列。让IO线程注意队列中的命令/数据。
您似乎正在为每个发送的事件分配和释放一些缓冲区。避免这样做。如果将所有IO保留在单个线程中，则可以重用单个缓冲区。无论如何，您正在限制消息的大小，您可以预先分配一个足够大的缓冲区。
将要发送的字节放入std::deque是不理想的。您必须将它们序列化为WriteFile()的连续内存块。相反，如果在一个IO线程和其他线程之间使用某种commdand / data队列，则可以让客户端线程一次提供连续的内存块。
一次读取1个字节似乎也很愚蠢。除非它不适用于串行设备，否则可以为ReadFileEx()提供足够大的缓冲区。它返回实际设法读取的字节数。它不应该阻止，AFAIK，除非我当然错了。
您正在等待重叠的IO完成SleepEx()调用。如果您刚刚结束同步，那么重叠IO的重点是什么？