.gitignoring *.swp *.prof and *.6
padded.Int64 using cacheLineBytes

The size of the cache line buffers before and after the int64 Value
field are taken from the archtecture dependent cacheLineBytes constant.
Single producer single consumer (spsc) queues

All queues must have only a single producer (writing) goroutine and a
single consumer (reading) goroutine. If more than one goroutine reads or
writes to the same queue no particular behaviour can be guaranteed.

There are three distinct queues impemented here. Each of those three
implementations comes in two flavours, safe and unsafe. The unsafe
queues all have the name Unsafe*Q and use the flib/fatomic/LazyStore()
function. All ringbuffer sizes must be a power of two.

ByteQ - The writer must provide a []byte (smaller than the ringbuffer)
to be written. A write either succeeds or fails, no partial writes
occur. The reader must provide a []byte (smaller than the internal
ringbuffer) the ByteQ will copy bytes into the []byte provided if it
can. A read either succeeds or failes, no partial reads occur.

ByteChunkQ - The queue provies access to a read and write buffer. The
buffers are the size of the 'chunk' of that queue. The size of the chunk
must divide cleanly into the size of the internal ringbuffer. The writer
can write into the write buffer and then commit those bytes to the
internal ringbuffer with a call to Write(). A call to Write() either
succeeds or fails, no partial writes occur. A reader can ask the queue
to copy bytes from the internal ringbuffer into the read buffer by a
call to Read(). A call to Read() either succeeds or fails, no partial
reads occur.

PointerQ - The writer can  write a single pointer to the queue using the
WriteSingle() method. Or the writer can acquire a []unsafe.Pointer of a
requested size using the WriteBuffer(int64) method. The buffer returned
can be equal to or less than the size requested, including zero. Writes
made to the buffer can be committed to the ringbuffer using the
CommitWriteBuffer(int64) method, the parameter indicates the number of
pointers to commit. The reader can read a single pointer from the queue
using the ReadSingle() method. Or the reader can acquire a
[]unsafe.Pointer or a requested size using the ReadBuffer(int64) method.
The buffer returned can be equal to or less than the size requested,
including zero. When the reader has read all pointers in the buffer the
reader can free that part of the internal ringbuffer by calling the
CommitReadBuffer(int64), the parameter indicates the number of pointers
to commit.