Could Qt Synchronisation classes be used with MSVC compiler

Question

In the Qt Synchronizing threads documentation listed here:

http://doc.qt.io/qt-5/threads-synchronizing.html

They wrote:

Note: Qt's synchronization classes rely on the use of properly aligned pointers. For instance, you cannot use packed classes with MSVC.

The sentence is not clear.

Which are the limitations of using Qt Synchronization classes with MSVC compiler?

If you don't use "packed classes" you should be OK to use them. Packed classes is where you manipulate the struct alignment. If you don't change anything here you are probably just fine. — Hayt, Aug 31 '16 at 13:33
@Hayt: thanks, +1. You can write a complete answer. I will upvote it. — ProEns08, Aug 31 '16 at 13:34

score 3 · Answer 1 · answered Aug 31 '16 at 16:29

3

You're facing a documentation bug, with following fix:

Note: Qt's synchronization classes rely on the use of properly aligned pointers. For instance, you cannot use t̲h̲e̲m̲ i̲n̲ packed classes ~~with MSVC~~.

MSVC is a red herring. Qt's synchronization classes don't work with packed structures period, on all platforms Qt is supported on - since all these platforms support packed structures, and know how to access unaligned members of such structures.

answered Aug 31 '16 at 16:29

Kuba hasn't forgotten Monica

95,931
16
151
313

could you explain more the cause for this. Why did you affirm that. Especially that the documentation is edited and revised by Qt developers themselves. – ProEns08 Aug 31 '16 at 16:32
The cause is very, very simple: nobody bothered to submit a fix to the documentation. Qt developers aren't some divine entity with unlimited time and resources. No documentation is perfect. – Kuba hasn't forgotten Monica Aug 31 '16 at 16:34
I upvoted your answer. To tick it as the answer, Your answer should be affirmed by Qt itself. – ProEns08 Aug 31 '16 at 16:36
Why did you say that MSVC is a red herring. I did not understand this expression. – ProEns08 Aug 31 '16 at 16:37
red herring means "something, especially a clue, that is or is intended to be misleading or distracting" – Kuba hasn't forgotten Monica Aug 31 '16 at 16:39
1

"Your answer should be affirmed by Qt itself." Haha. You can test it yourself. It's not hard. You don't have to trust me, or Qt developers either! – Kuba hasn't forgotten Monica Aug 31 '16 at 16:41
Did you mean that Qt documentation editor put this false information premeditated? – ProEns08 Aug 31 '16 at 16:53
1

Not at all. I mean that appeal to authority is unnecessary. If you're seeking truth, you don't need to trust neither documentation nor me. Trust experimental results and machine code. – Kuba hasn't forgotten Monica Aug 31 '16 at 19:39

score 2 · Answer 2 · edited May 23 '17 at 10:29

2

It should not be an issue if you don't use packed classes (if you don't know what that is you are likely not to be using them).

See here for some information about what they are: Class contiguous data

edited May 23 '17 at 10:29

Community

1
1

answered Aug 31 '16 at 13:39

Hayt

5,210
30
37

Actually, packed classes are just one of the examples that could cause a failure. Therefore, avoiding packed classes is necessary but not sufficient. – MSalters Aug 31 '16 at 15:14

score 2 · Accepted Answer · answered Aug 31 '16 at 15:25

Alignment refers to a restriction on the addresses of objects of certain types. For the compilers supported by Qt, there's just one sort of alignment restriction: some addresses should be a multiple of 2,4 or 8.

There are a few ways in which this restriction can be violated. In a packed class, when you have a float followed by a char followed by another float there will be no gaps between the three members (that's why they're called packed). As a result, the second float has an address that's 5 higher than the first. It's fairly obvious that one of the two addresses is not a multiple of 4 (the alignment of float).

Another way in which this can occur is casting a random char* to float*. The last two bits of the char* should be zero in this case.

MSVC++ can deal with such unaligned data (it's just slightly slower), but it does so by having the CPU load the data in two operations. This breaks Qt's synchronization which assumes that data is loaded in one operation, such that you get either an old or a new value. If the load is split in two operations, the first may see an old value and the second a new value. The result is that the register contains a mix of old and new bits (!)

@ProEns08 You don't really need to comment on your upvotes etc. — Kuba hasn't forgotten Monica, Aug 31 '16 at 16:40

Could Qt Synchronisation classes be used with MSVC compiler

3 Answers3