This allows the DP4A library to be used, which is way faster

I.e., call xGPU passing pointers to already transferred
data on the device. This gives up xGPU's pipelining abilities,
but makes it easier to use the xGPU kernel alongside other consumers
also using the same GPU input buffer.

Add some checking for proper pointer spaces. More checking required

Inspired by the CUBLAS usage in https://github.com/devincody/DSAbeamformer

Operates in 3 steps --
1. Tranpose data and promote to float
2. Compute beams
3. Compute beam dynamic spectra, and sum to (in LWA352's case) 1ms

Assumes no polarization ordering of input, but relies on user to
upload beamforming coefficients which create X-pol and Y-pol beams.
This is an easy way to deal with the arbitrary input ordering at runtime,
but isn't very efficient (half the beamforming coeffs are zero).
The kernel assumes the beams are constructed like this and uses the
fact to generate averaged dynamic spectra (XX, YY, XY_r, XY_i).

May well have synchronization bugs which make the benchmarks meaningless,
but currently obtains ~50 Gbps throughput (~9MHz bandwidth for 4-bit inputs) with

NANTS = 352
NPOLS = 2
NCHANS = 192 (4.4 MHz for LWA352)
NBEAMS = 32 (16 x 2-pols)
NTIMES = 480
NTIMES_SUM = 24 (1ms)

Move IB verbs receiving class to a dedicated C file. When
using the hashpipe_ibverbs library within packet_capture.hpp
directly something in that file messes up the compatibility
of the ibverbs structs (their sizes are different) to those
interpretted by hashpipe. Odd, but working around for now.

Evidently, this is the trigger to make `like_bmon` work
its magic

Increase RX packet depth of IB verbs interface to 32k (this
seems to be the maximum).

Make packet handler use AVX stream store instructions.

1. The receiver is currently hard coded for 64 pols per packet.
   It would be trivial to parameterize this, but it may have some
   small performance implication.
2. Code loads 64-bit values into a 256-bit AVX register before writing
   to memory. If the IBV interface can be tweaked to enforce alignment
   (talk to DM about this) the first stage won't be necessary.
3. 64 pols per packet = 512 bits per memory write (1 freq channel of data).
   Newer machines supporting AVX512 could probably run faster than the current
   code by using _mm512_stream_si512 in place of _mm256_stream_si256

The behaviour of the traceback library has changed in py3, so remove
the now nonexistent call.

Tweak error handling to properly pass an exception to the cleanup print

Fix missing decode()

Time metrics for processing / waiting for input/output
data are helpful for figuringout the bottlenecks in the
pipeline, but aren't particularly intuitive (IMO)
measures of whether things are "fast enough"

This is a gross thing to hardcode, so FIXME.
But, having new sequences periodically means that the header
timestamps can be used as actual timestamps, rather
than just counting bytes in some infinite data stream (which
doesn't seem like a good idea when the input stream is from a
network, and could conceivably behave strangely).

Having timestamps derived from actual packet headers periodically
seems sensible(?)

Lwa352 ibv

Allow an option to beamform and integrate in one hit by
passing ntime_blocks>0 when initializing the library. Otherwise
don't transpose or integrate the data.

This change allows multiple downstream processes to use raw beamformer
data for their own, different purposes -- (eg) one generating integrated
dynamic spectra, and one generating VLBI voltage beams

…o lwa352-ibv

Reaches 27Gbps on LWA352 pipeline

Replace JH's libhashpipeibverbs IBV capture code with JD's dedicated bifrost
source. Remove the philosophical quirk of having bifrost depend on hashpipe.

Sequence only changes if out-of-order packets indicate
the upstream transmitters have reset

Round start of seq to a gulp size.
Decide if a sequence has ended by checking if the first packet of the next sequence
is the current time step + gulp size

This enforces gulp_size = slot_size. But, it's not obvious slot size actually
does anything other than set the time granularity at which a buffer may start

Python 3.7 enables https://www.python.org/dev/peps/pep-0479/

StopIteration errors are, from Python 3.7, promoited to RuntimeErrors
and must be explicitly handled by user code.
See https://stackoverflow.com/questions/51700960/runtimeerror-generator-raised-stopiteration-every-time-i-try-to-run-app

And feed sync time into the pipeline time_tag

This is no longer necessary now there is a dedicated UDPVerbsCapture class

Fix bugs and set conjugation convention such that
given a visibility matrix in order:

[stand0, stand1, pol0, pol1]

The conjugation of the data is (stand0, pol0) * conj(stand1, pol1)

- Add function to accumulate a single beam from a buffer of many
- Make accumulation functions take acc_len as an arg rather than reading from context

Add JD's `pbeam` formats

 Conflicts:
	python/bifrost/packet_capture.py
	src/formats/formats.hpp
	src/packet_capture.hpp
	test/travis.sh

test/travis -- not a real conflict.
others -- manually merge pbeam and snap2 packet formats.

…o lwa352

Add JH's lwa-ov voltage output format. This was mostly an exercise in playing
with bifrost's packet transmission mechanism -- JD might redo this?

Put UDPVerbsCapture back in after mismerging it out

Got lost in the wash somewhere

This makes a pretty big difference at high packet RX rates

… packets

Allow two slots of loss before considering the sequence new.

chan0 is used internally for the channel number within a
single pipeline -- i.e., it is always 0 for the first channel
in a given packet stream. Rather than messing with this, use
the "tuning" packet header field to pass the actual channel
number to the bifrost capture callback

… into lwa352

Parroting JD:

The pragma pack compiler directive affects all structures following
the pragma. So, an innocent struct in a header file which wants
to be packed can mess up other code in fun ways, depending on orders of
header includes.
For some reason, IB Verbs configuration seems to be easily broken by
this kind of thing.

Use struct __attribute__((packed)) {...} instead

I'm not smart enough to make the python bindings get generated when
the header entries are wrapped in #if's

Blindly copied from the now-deprecated implementation in ib_verbs.cpp

TODO: Is there a more sensible (less-transposey)
data ordering. [Probably]

This is actually quite annoying. The call to blank a source
doesn't know about the details of the packet structure, and one can't
necessarily blank the right parts of the receive buffer when only given
nsrc, src, nchan, chan, since these values have been abused. E.g.
the output buffer is in Time x Chan x Antpol order, but the Chan
dimension can be a multiple of nchan, and nsrc != the number of Antpols in the system.

Hack the information out of the packet stream and then write a clurgy blanking
function.

Barely tested.

This reverts commit b107bfc.

Don't do this for now to make things faster

COR packet format updates

…rost into lwa352