4

我正在为 Windows 编写一个串口软件。为了提高性能,我尝试将例程转换为使用异步 I/O。我已经编写好代码并且工作得相当好,但我是这方面的半初学者,我想进一步提高程序的性能。在程序的压力测试期间(即以高波特率尽可能快地向/从端口突发数据),CPU 负载变得相当高。

如果有人在 Windows 中具有异步 I/O 和多线程方面的经验,如果您能看看我的程序,我将不胜感激。我有两个主要担忧:

  • 异步 I/O 是否正确实现?我在网上找到了一些相当可靠的来源,建议您可以通过在最后用您自己的数据实现您自己的 OVERLAPPED 结构来将用户数据传递给回调函数。这似乎工作得很好,但对我来说确实有点“骇人听闻”。此外,当我从同步/轮询转换为异步/回调时,程序的性能并没有太大改善,这让我怀疑我做错了什么。

  • 将 STL std::deque 用于 FIFO 数据缓冲区是否合理?由于程序当前正在编写,我只允许一次接收 1 个字节的数据,然后必须对其进行处理。因为我不知道我会收到多少数据,所以可能是无穷无尽的。我假设当它必须分配数据时,这种每次 1 字节的行为会在双端队列后面产生缓慢的行为。而且我也不相信双端队列是线程安全的(我应该吗?)。如果使用 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);
}
4

3 回答 3

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 线程不同。

于 2011-03-07T15:33:32.947 回答
1

我看不出有任何理由在这样的项目中使用异步 I/O。当您处理大量套接字或在等待数据时有工作要做时,异步 I/O 很好,但据我所知,您只处理一个套接字,中间不做任何工作.

此外,为了了解知识,您通常会使用 I/O 完成端口来处理异步 I/O。我不确定是否存在使用 I/O 完成端口对性能产生负面影响的情况。

但是,是的,您的异步 I/O 使用看起来还不错。实现你自己的OVERLAPPED结构确实看起来像一个 hack,但它是正确的;没有其他方法可以将您自己的数据与完成相关联。

Boost 还有一个循环缓冲区实现,虽然我不确定它是否是线程安全的。但是,没有一个标准库容器是线程安全的。

于 2011-03-07T15:34:00.827 回答
1

我认为您的代码设计欠佳。

  • 我猜你正在与太多线程共享太多数据结构。我认为您应该将一个端口的串行设备 IO 的所有处理放到一个线程中,并在 IO 线程和所有客户端线程之间放置一个同步的命令/数据队列。让 IO 线程注意队列中的命令/数据。

  • 您似乎正在为每个发送的事件分配和释放一些缓冲区。避免这种情况。如果将所有 IO 保存在单个线程中,则可以重用单个缓冲区。无论如何,您都在限制消息的大小,您可以预先分配一个足够大的缓冲区。

  • 将要发送的字节放入 astd::deque是次优的。您必须将它们序列化为WriteFile(). 相反,如果您在一个 IO 线程和其他线程之间使用某种命令/数据队列,您可以让客户端线程一次提供连续的内存块。

  • 一次读取 1 个字节似乎也很愚蠢。除非它不适用于串行设备,否则您可以为ReadFileEx(). 它返回它实际设法读取的字节数。它不应该阻止,AFAIK,除非我当然错了。

  • 您正在等待重叠的 IO 完成使用SleepEx()调用。那么,如果您最终只是同步,那么重叠 IO 的意义何在?

于 2011-03-07T15:46:14.580 回答