paq | PAQ is a series of archivers | Time Series Database library

You didn't include the definition for your decimal price column, but here is a definition which should resolve the error:

If the received packet is in the byte array p, you can search for the 0 delimiters with find().

I have been told today that there is no need for any Interlocked function call when reading and writing a 32bit long value

Because it's not true, at least not that generic.

Only applies to x86, and only if the 32bit value type is aligned, and the variable is actually comitted to memory using a single 32bit wide instruction. Which is commonly the case, but by no means guaranteed, neither the alignment nor the atomic store as the compiler may decide to optimize or can not assume alignment and has therefor to split.

Doesn't this contradict MSDN; if the read/write is atomic, why is this Interlocked function needed?

An atomic_long is not aligned by definition, so an atomic exchange is required for formally correct function.

This function generates a full memory barrier (or fence) to ensure that memory operations are completed in order.

And that is the other relevant part about atomics - they form a memory barrier.

Which means that neither the compiler nor the processor can re-order memory accesses. If you had e.g. two plain int variables which you were writing to independently in the same scope, the compiler would be free to batch or re-order the writes as it likes.

As a side effect, the processor will also attempt to synchronize the caches, so you will see updates made to an atomic variable on another core much faster.

This goes beyond the effect of a plain volatile which would also prevent reordering memory access, but could still spend several microseconds waiting for memory writes to be flushed on another core.

If I am using VS 2005 and targeting Windows XP, how would I ensure an atomic read/write of a boolean variable? Would I have to use a mutex or similar?

Yes. Well, the write is atomic, either way, but you really want the memory barrier if you have been using the boolean to signal that another memory region is now safe to access (e.g. spinlock).

If a read/write operation is not atomic, that leaves it susceptible to being torn; is that correct?

Not for a bool, as it is really just one byte, and I'm not aware of any architecture out there which could tear a variable on the sub-byte level.

For all larger types, yes, as aligment is not guaranteed. And as said before, you don't have any guarantees that the compiler used an atomic instruction, even if it had been "for free".

Using tr to translate each wanted character classes to a digit, sorting that digit string and count matching with grep (using @glennjackman defined character classes except the exact length):