[Merged] copying data from structure to a ByteArray and vise versa
-
Do you need memmove for speedup or for something else? In first case I think using QByteArray will remove all advantages of using memmove.
-
Denis: Why? You can reserve a chunk of memory and qMemCopy into it. Why is that slower as using some other method?
-
phamtv: I'd recommend using qMemCopy/qMemSet from QtCore/QtGlobal. I think those are not documented, so they are not officially supported, but they work well for me.
-
Tobias, hm, I mostly saying that from my point of view memmove and other c things should be used now only if you are know what you are doing (e.g. if you need to speed up your memory management). In common cases such low-level work is not needed. And in case of mixing memmove for initializing data and using QByteArray to work with it I think initial speedup from memmove will be neglected by QByteArray abstractions.
-
Denis: You are right that you should not need these low level functionality 95% of the time... but it is still very useful for the last 5%:-)
I actually do not think that the QByteArray overhead is that big by the way (I did not do any measurements though), it is just a wrapper around a piece of memory after all. Resizing the buffer is of course expensive and needs to be avoided.
-
phamtv: You did read the "documentation of QByteArray":http://doc.trolltech.com/4.7/qbytearray.html, didn't you? It states quite clearly how to access its buffer.
-
yes I have read the QByteArray document. I am still puzzled on the benefits of a QByteArray. My background with byte arrays have always been something similar to quint8 arr[] in which I can later cast to whatever my data structure is. Besides dynamic resizing of the array size, are there any other advantages to QByteArray over the quint8[]? Also, is it true that if I use the QByteArray, I should use the qMemCopy/qMemSet from QtCore/QtGlobal instead of the memmove, memcpy???
-
To quote the documentation:
QByteArray can be used to store both raw bytes (including '\0's) and traditional 8-bit '\0'-terminated strings. Using QByteArray is much more convenient than using const char *. Behind the scenes, it always ensures that the data is followed by a '\0' terminator, and uses implicit sharing (copy-on-write) to reduce memory usage and avoid needless copying of data.
Using QByteArray or not does not matter for qMemCopy or memcpy. The first is just a wrapper around the latter anyway. qMemCopy will be there wherever Qt is available, and it is in a Qt header which is included in almost all Qt code.
-
That time tests:
@ QByteArray ba1(2048, 0);
QByteArray ba2(2048, 255);
QByteArray ba3(1024, 255);
char *ba1data = ba1.data();
char *ba2data = ba2.data();QElapsedTimer timer;
timer.start();for (int i = 0; i < 100000000; i++)
{
//ba2.replace(1000, 1024, ba1.data()+1000, 1024); // For 12324 ms.
//ba2.replace(1000, 1024, ba1.mid(1000, 1024)); // For 33228 ms.
//ba3 = ba1.left(1024); // For 45615 ms. <- ?!
//ba3 = ba1.right(1024); // For 29640 ms.
//ba3 = ba1.mid(1000, 1024); // For 29859 ms.//memcpy(ba2data+1000, ba1data+1000, 1024); // For 7722 ms. qMemCopy(ba2data+1000, ba1data+1000, 1024); // For 11981 ms.}
qDebug() << timer.elapsed();@