Qt TCP向ECU传输大数据崩溃，求优化方案及QDataStream用法

Hey there, let's tackle your issues step by step—since you're new to Qt/C++, it's totally normal to hit snags with large data transfers. Let's start with your two questions, and also cover a couple of potential crash triggers in your current code:

Your current for-loop to fill the buffer with 'a's works for small sizes, but it's inefficient and unnecessary for large data. Here are way better options:

• Use Qt's qMemSet function: This is a cross-platform, optimized memory-fill utility that's way faster than a manual loop. It's designed exactly for this kind of bulk byte setting:

  qMemSet(transferSendBuffer, 'a', size);
  

  It's equivalent to C's standard memset, but wrapped for Qt's cross-platform compatibility.

• Use C++ Standard Library's std::fill_n: If you prefer standard C++ over Qt-specific functions, this works too (though qMemSet/memset will be slightly faster for byte-level fills):

  #include <algorithm>
  std::fill_n(transferSendBuffer, size, 'a');
  

• Skip manual filling entirely with QByteArray: If you switch to using QByteArray instead of a raw uint8_t buffer, you can initialize it with the desired character and size in one go—no loops needed, and it manages memory safely:

  QByteArray buffer(size, 'a');
  // Then send it directly:
  out.writeRawData(buffer.constData(), buffer.size());
  

  This also avoids risks of buffer overflow if your raw buffer was improperly sized.

Looking at your TCPClient::sendData code, there are a few issues that could cause crashes with large transfers, plus optimizations to make it more efficient:

Critical Fix: Avoid writeBytes if you don't need length prefixes #

QDataStream::writeBytes() automatically writes a 4-byte quint32 length prefix before your data. If your ECU isn't expecting this prefix, it'll misinterpret the data, leading to corrupted transfers or crashes. For raw byte transfers (like your benchmark), use writeRawData() instead—it sends exactly the bytes you pass without any extra headers:

// Replace this:
out.writeBytes((const char*)buffer, size);
// With this:
out.writeRawData((const char*)buffer, size);

Optimization 1: Make QDataStream a member variable #

Right now, you're creating a local QDataStream out; inside sendData() and calling setDevice every time. This adds unnecessary overhead, especially with thousands of calls for large transfers. Instead, initialize the stream once in your TCPClient constructor:

// In TCPClient.h:
class TCPClient {
private:
    QDataStream out_; // Member variable
    QTcpSocket* socket_aurix;
    // ... other members
};

// In TCPClient.cpp constructor:
TCPClient::TCPClient(QObject* parent) : QObject(parent) {
    socket_aurix = new QTcpSocket(this);
    out_.setDevice(socket_aurix);
    out_.setVersion(QDataStream::Qt_5_15); // Set to your Qt version for compatibility
}

// Then in sendData():
void TCPClient::sendData(uint8_t* buffer, uint32_t size) {
    qDebug() << "current send size: " << size;
    qMemSet(buffer, 'a', size);
    out_.writeRawData((const char*)buffer, size);
}

Optimization 2: Batch transfers where possible #

Your current loop sends 1024-byte chunks (or smaller for the last chunk), which is fine, but you can reduce the number of sendData calls by using larger buffers (if your network and ECU support it). Just adjust BENCHMARK_TRANSFER_BUFFER_SIZE to a bigger value like 4096 or 8192—this cuts down on function call overhead and syscalls.

Optimization 3: Flush strategically #

If you're sending a lot of small chunks, the underlying socket might buffer data, but for benchmarks, you can call out_.flush() after sending all chunks to ensure all data is pushed out immediately. Though for large transfers, the socket will flush automatically when its buffer is full.

Bonus: Check for Socket Errors #

Crashes with large transfers might also be due to unhandled socket errors (like disconnections or buffer limits). Add error handling to your TCPClient to catch these:

// Connect socket error signal in constructor:
connect(socket_aurix, &QTcpSocket::errorOccurred, this, [this](QAbstractSocket::SocketError err) {
    qDebug() << "Socket error:" << socket_aurix->errorString();
    // Handle error (e.g., abort transfer, reconnect)
});

内容的提问来源于stack exchange，提问作者Chris Nelson