Change intcount from 2048 to 1024

This changes the default integration time back to ~10.7 seconds.  Now that
we have 1024 channels, there are twice as many spectra per mcount so we
have to count half as many to get to ~10.7 seconds.
Make paper_init really launch the processes
Mcnt rollovers are now seen and treated like any other out of sequence mcnt.
This simplified calc_block_indexes().
Only increase RLIMIT_MEMLOCK if we need to, and then only once.
On out-of-sequence reset, mark all data as bad.
Merge remote branch 'origin/jeffc'
Update paper_gpu_thread for xGPU v1.5.0

This also includes some preprocessor macros that maintain backward
compatibility with pre-v1.5.0 xGPU versions.  While these macros provide
backwards compatibility, they do not fix or work around issues in
pre-v1.5.0 versions of xGPU.  Use of xGPU v1.5.0 or later is required
for reliable operation.
Make dynamic sizing of data buffers more versatile

Makes the dynamic sizing of input data buffers more versatile and
robust.  Specifically, these chagnes are intended to handle the case
where the X engine data rate is greater than the F engine data rate.
Compute and print usec/pkt when doing TIMING_TEST

This makes the measurement more accurate than running the TIMING_TEST
as "time paper_xgpu ...", especially since sleeping has been added
between thread startups.
Update NETMCNT only when marking a block filled

Fixes a bug that was inadvertently introduced in commit 0fc570f.  That
commit changed when blocks are marked as filled, but it inadvertently
also changed the return sematics of write_paper_packet_to_blocks() in
such a way that the NETMCNT status variable was updated every packet
instead of just when marking a block as full.  This had a very
detrimental impact on packet processing times.
Change N_BYTES_PER_PAYLOAD to N_BYTES_PER_PACKET

Like N_BYTES_PER_PAYLOAD, N_BYTES_PER_PACKET excludes the 8 byte header.
Reduce TIMING_TEST loop to only 1 million packets

Now that the timing for TIMING_TEST is done internally, there is no need
to amortize the startup cost over such a large number of packets.
Conditionally enable paper_net_thread XID handling

Only include XID handling when N_CHAN_PER_X != N_CHAN_PER_PACKET.
Add paper_fluff.{c,h} and paper_fluff_test.c

paper_fluff.{c,h} contain a cache efficient fluffing routine that fluffs
an entire block of 4bit+4bit complex input data into a block of
8bit+8bit complex output data with a complex block size of 32.
Convert "inherited" databuf functions to inline
Add paper_gpu_input_databuf

paper_gpu_input_databuf will hold 8bit+8bit (i.e. fluffed) complex data
used complex block size 32 (i.e. in the format expected by the GPU).
paper_input_databuf is being converted to hold only 4bit+4bit complex
data (i.e. unfluffed data).  A new fluffer thread will eventually fluff
the data from paper_input_databuf blocks into paper_gpu_input_databuf
blocks.

This is a work in progress and does not currently compile due to
paper_net_thread still needing updates to track the changes to
paper_input_databuf.
Update paper_fake_net_thread to new input dataduf
Update paper_gpu_thread to new input databuf

Does not yet update it to use paper_gpu_input_buffer, so although it now
compiles cleanly it does not provide correct functionality.
Update paper_net_thread to new input datatbuf

paper_net_thread no longer fluffs data!  It now only copies the 4 bit
data into the destination block's data buffer using the new 6
dimensional indexing scheme.
Explicitly dimension paper data blocks

When paper_input_block was modified to have only a single data field,
the explicit dimensioning was omitted.  That caused problems for
allocating arrays of them (or arryas of structures that contained them).
paper_gpu_input_block had the same problem.  Both are now fixed.