Mutex lock/unlock should not fail if mutex was correctly initialized/used.

And specifically that GC'ed object __del__ calls into virtmem
(vma_dealloc and fileh_dealloc) again.

NOTE not sure it is a good idea to do GC from under sighandle, but
     currently it happens in practice, because we did not cared to
     protect against it.

We factored out SIGSEGV block/restore from fileh_dirty_writeout() to all
functions in cb7a7055 (bigfile/virtmem: Block/restore SIGSEGV in
non-pagefault-handling function). The restoration however just sets
whole thread sigmask.

It could be possible that between block/restore calls procmask for other
signals could be changed, and this way - setting procmask directly - we
will overwrite them.

So be careful, and when restoring SIGSEGV mask, touch mask bit for only
that signal.

( we need xsigismember helper to get this done, which is also introduced
  in this patch )

The mistake was there from the beginning - from 3e5e78cd (lib/utils:
Small C utilities we'll use).

We'll need this for function which return error not in errno - e.g.
pthread_sigmask().

http://mail.tiolive.com/pipermail/neo-users/20150713/000027.html

Non on-pagefault code should not access any not-mmapped memory.

Here we just refactor the code we already had to block/restore
SIGSEGV from fileh_dirty_writeout() and use it in all functions called
from non-pagefaulting context, as promised.

This way, if there is an error in virtmem implementation which
incorrectly accesses prepared for BigFile maps memory, we'll just die
with coredump instead of trying to incorrectly handle the pagefault.

ca064f75 (bigarray: Support resizing in-place) added O(1) in-place
BigArray.resize() which makes possible for users to append data to BigArray in
O(δ) time.

But it is easy for people to make off-by-one mistakes when calculating
indices for append.

So provide a convenient BigArray.append() which simplifies the following

    A                               # ZBigArray e.g. of shape       (N, 3)
    values                          # ndarray to append of shape    (δ, 3)
    n, δ = len(A), len(values)      # length of A's major index  =N
    A.resize((n+δ, A.shape[1:]))    # add δ new entries ; now len(A) =N+δ
    A[-δ:] = values                 # set data for last new δ entries

into

    A.append(values)

/cc @klaus

We stopped using numpy.multiply in 73926487 (*: It is not safe to use
multiply.reduce() - it overflows).

We compare A_[10*PS-1] (which is A_[1]) to 0, but

    A_= ndarray ((10*PS,), uint8)

and that means the array memory is not initialized. So the comparison
works sometimes and sometimes it does not.

Initialize compared element explicitly.

NOTE: A (without _) element does not need to be initialized -
because not-initialized BigArray parts read as zeros.

/cc @jm

Previously we were always testing with DBs backed up by FileStorage. Now
we provide a way to run the testsuite with user selected storage
backend:

    $ WENDELIN_CORE_TEST_DB="<fs>"   make test.py     # test with temporary db with FileStorage
    $ WENDELIN_CORE_TEST_DB="<zeo>"  make test.py     # ----------//---------- with ZEO
    $ WENDELIN_CORE_TEST_DB="<neo>"  make test.py     # ----------//---------- with NEO

    $ WENDELIN_CORE_TEST_DB=neo://db@master  make test.py     # test with externally provided DB

Default is still to run tests with FileStorage.

/cc @jm

And this way, because dbopen() supports opening various kind of
databases (see previous commit) we can now specify type of database on
command line, e.g.

    /path/to/db
    neo://db@master
    zeo://host:port

/cc @jm

Done via manual hacky way for now. The clean solution would be to reuse
e.g. repoze.zodbconn[1] or zodburi[2] and teach them to support NEO.

But for now we can't -- those eggs depend on ZODB, and we still use
ZODB3 for maintaining compatibility with both ZODB3.10 and ZODB4.

/cc @jm

[1] https://pypi.python.org/pypi/repoze.zodbconn
[2] https://pypi.python.org/pypi/zodburi

Factor out those routines to open a ZODB database to common place.

The reason for doing so is that we'll soon teach dbopen to automatically
recognize several protocols, e.g. neo:// and zeo:// and this way,
clients who use dbopen() could automatically access storages besides
FileStorage.

Because numpy.ndarray does not accept it as buffer= argument

    https://github.com/numpy/numpy/issues/5935

and our memcpy crashes.

NOTE if we'll need to use memoryview, we can adapt our memcpy to use
array() directly which works with memoryview, as outlined in the above
numpy issue.

BigArrays can be big - up to 2^64 bytes, and thus in general it is not
possible to represent whole BigArray as ndarray view, because address
space is usually smaller on 64bit architectures.

However users often try to pass BigArrays to numpy functions as-is, and
numpy finds a way to convert, or start converting, BigArray to ndarray -
via detecting it as a sequence, and extracting elements one-by-one.
Which is slooooow.

Because of the above, we provide users a well-defined service:
- if virtual address space is available - we succeed at creating ndarray
  view for whole BigArray, without delay and copying.
- if not - we report properly the error and give hint how BigArrays have
  to be processed in chunks.

Verifying that big BigArrays cannot be converted to ndarray also tests
for behaviour and issues fixed in last 5 patches.

/cc @Tyagov
/cc @klaus

e.g.

    In [1]: multiply.reduce((1<<30, 1<<30, 1<<30))
    Out[1]: 0

instead of

    In [2]: (1<<30) * (1<<30) * (1<<30)
    Out[2]: 1237940039285380274899124224

    In [3]: 1<<90
    Out[3]: 1237940039285380274899124224

also multiply.reduce returns int64, instead of python int:

    In [4]: type( multiply.reduce([1,2,3]) )
    Out[4]: numpy.int64

which also leads to overflow-related problems if we further compute with
this value and other integers and results exceeds int64 - it becomes
float:

    In [5]: idx0_stop = 18446744073709551615

    In [6]: stride0   = numpy.int64(1)

    In [7]: byte0_stop = idx0_stop * stride0

    In [8]: byte0_stop
    Out[8]: 1.8446744073709552e+19

and then it becomes a real problem for BigArray.__getitem__()

    wendelin.core/bigarray/__init__.py:326: RuntimeWarning: overflow encountered in long_scalars
      page0_min  = min(byte0_start, byte0_stop+byte0_stride) // pagesize # TODO -> fileh.pagesize

and then

    >           vma0 = self._fileh.mmap(page0_min, page0_max-page0_min+1)
    E           TypeError: integer argument expected, got float

~~~~

So just avoid multiple.reduce() and do our own mul() properly the same
way sum() is builtin into python, and we avoid overflow-related
problems.

We need this commit:

    http://git.ozlabs.org/?p=ccan;a=commitdiff;h=c38e11b508e52fb2921e67d1123b05d9bef90fd2

or else we segfault on really big arrays allocation instead of getting
ENOMEM and reporting it as MemoryError to python.

Consider e.g. this for pyvma:

    1. in pyfileh_mmap() pyvma is created

    2. next fileh_mmap(pyvma, pyfileh, ...) fails

    3. we need to deallocate pyvma which was not mapped

    4. in pyvma_dealloc() we unmap pyvma unconditionally -> boom.

The same story goes for pyfileh dealloc vs not fully constructing it in
pyfileh_open().

OverflowError when computing slice indices practically means we'll
cannot allocate so much address space at next step:

    In [1]: s = slice(None)

    In [2]: s.indices(1<<62)
    Out[2]: (0, 4611686018427387904, 1)

    In [3]: s.indices(1<<63)
    ---------------------------------------------------------------------------
    OverflowError                             Traceback (most recent call last)
    <ipython-input-4-5aa549641bc6> in <module>()
    ----> 1 s.indices(1<<63)

    OverflowError: cannot fit 'long' into an index-sized integer

So translate this OverflowError into MemoryError (preserving message
details), because we'll need such "no so much address space" cases to
show up as MemoryError in a sooner patch.

Currently we always raise RuntimeError for problems, which is
more-or-less ok for humans, but soon we'll need to distinguish "no
memory" errors from other error conditions in upper layers in code.

Introduce helper function for choosing appropriate exception type for an
error - MemoryError for when errno=ENOMEM and RuntimeError otherwise,
and use it where appropriate.

( Unfortunately Python does not provide such a helper... )

As discussion in https://bitbucket.org/pypa/setuptools/issue/313
unveiled, setuptools do not have to carry setuptools.file_finders
entrypoint with it in order to support _other_ projects to use
.file_finders entry point.

In our case it means that is is normal that we have to make sure that
the group we are going to register entry-point into, exists.

Remove erroneous comments introduced in 11d130d1 (setup: Ensure
setuptools.file_finders entry-point group is registered).

py2-only syntax introduced in acf7e91d (setup/runcmd: Properly report
errors, if running command is missing):

      File "setup.py", line 168
        except Exception, e:
                        ^
    SyntaxError: invalid syntax

The reason is some people are blocked to access git:// protocol/port
because of firewall setup in their environment, and git.ozlabs.org does
not provide a way to clone over http(s).

We can provide CCAN mirror and we support cloning it over http(s). Also,
it makes sense to not depend on thirdparty sites for hosting
strongly-related components.

We currently use subprocess.check_output() for running external command
(git), and check_output() checks running command status code, as its
name promises:

    https://github.com/python/cpython/blob/2.7/Lib/subprocess.py#L569

and reports it appropriately to user:

    https://github.com/python/cpython/blob/2.7/Lib/subprocess.py#L411

but if the command is not found, it is just single

    error: [Errno 2] No such file or directory

which gets output to the log and it is not clear what command failed, or
evern if it is from runcmd() call.

Redo our runcmd() manually, so that it always report erros with context
- what command it was trying to run. The error now becomes:

   RuntimeError: (['missing-command'],): [Errno 2] No such file or directory

/cc @Tyagov

If setuptools.file_finders group is not registered,
dist.get_entry_map('setuptools.file_finders') returns just {} not
connected to entry map, and further modifications of this dict go
nowhere (and thus, our git_lsfiles() is not hooked -> sdist fails to
produce correct source archive).

This is a workaround for setuptools 9.0 dropping
`setuptools.file_finders` entrypoint group registration:

    https://bitbucket.org/pypa/setuptools/commits/f191c8a1225bd58a5fb5aa9abb31b06dc710f0b9#Lsetup.pyF175
    https://bitbucket.org/pypa/setuptools/issue/313

issue reported back:

    https://bitbucket.org/pypa/setuptools/issue/313#comment-18430008

It was hanging with NumPy-1.9 before 425dc5d1 (bigarray: Raise
IndexError for out-of-bound element access), because of the following
correct NumPy commit:

    https://github.com/numpy/numpy/commit/d36f8227

and in particular

    https://github.com/numpy/numpy/commit/d36f8227#diff-6d326badc0872de91e025cbfb0be1aafR522

That PySequence_Fast(obj)    (with obj being BigArray)

creates iterator on top of obj and before our previous IndexError fix in
425dc5d1, this was looping forever.

Test explicitly with both NumPy 1.8 and NumPy 1.9, that this construct
does not hang.

/cc @Tyagov

The way BigArray.__getitem__ works for element access is that for e.g.

    A[i]

it translates the request to

    A[i:i+1]

and remembers to lower the dimensionality at scalar index

    dim_adjust = (0,)

so, in full, A[i] is computed this way:

    A[i] -> A[i:i+1](0,)

( it is done this way to unify code for scalar / slice access in
  __getitem__ - see 0c826d5c "BigArray: An ndarray-like on top of
  BigFile memory mappings" )

The code for slice access also has a shortcut - if it sees that slice
results in empty array (e.g. for out-of-bound slice), we can avoid
spending time to create a file vma mapping only to create empty view on
top of it.

In 0c826d5c, that optimization, however forgot to apply the "lower the
dimensionality" step on top of resulting empty view, and that turned out
for not raising IndexError for out-of-bounds scalar access:

    A = BigArray((10,), uint8)
    In [1]: A[0]
    Out[1]: 0

    In [2]: A[1]
    Out[2]: 0

    In [3]: A[2]
    Out[3]: 0

    In [4]: A[9]
    Out[4]: 0

    In [5]: A[10]
    Out[5]: array([], dtype=uint8)

NOTE that A[10] returns empty array instead of raising IndexError.

So do not forget to apply the "reduce dimensionality" step for empty
views, and this way we get proper IndexError (because for empty view,
scalar access results in IndexError).

NOTE:

this bug was also preventing for e.g.

    list(A)

to work, because list(A) internally works this way:

    l = []
    i = iter(A)
    for _ in i:
        l.append(_)

but iterating would not stop after 10 elements - after array end, _ will
be always array([], dtype=uint8), and thus the loop never finished and
memory usage grow to infinity.

/cc @Tyagov

In NumPy speak advanced indexing is picking up arbitrarily requested
elemtnts, e.g.

    a = arange(10)
    a[[0,3,2]]  -> array([0, 3, 2])

The way this indexing schem works is - it creates a new array with
len = len(key), and picks up requested elements sequentially into new
area.

So it is very not the same as creating _view_ to original array data by
using basic indexing [1]

BigArray does not support advanced indexing, because its main job is to
organize an ndarray _view_ backed up by BigFile data and give that view
to clients, and then it is up to clients how to use that view with full
numpy api available with it.

So be explicit, and reject advanced indexing in __getitem__ right at the
beginning.

[1] http://docs.scipy.org/doc/numpy/reference/arrays.indexing.html

Else, in a clean repo the tests do not build from scratch:

    $ make test
    x86_64-linux-gnu-gcc -pthread -g -Wall -D_GNU_SOURCE -std=gnu99 -fplan9-extensions -Wno-declaration-after-statement -Wno-error=declaration-after-statement  -Iinclude -I3rdparty/ccan -I3rdparty/include   bigfile/tests/test_virtmem.c lib/bug.c lib/utils.c 3rdparty/ccan/ccan/tap/tap.c  -o bigfile/tests/test_virtmem.t
    In file included from include/wendelin/list.h:11:0,
                     from include/wendelin/bigfile/virtmem.h:33,
                     from bigfile/tests/../virtmem.c:23,
                     from bigfile/tests/test_virtmem.c:21:
    3rdparty/ccan/ccan/array_size/array_size.h:4:20: fatal error: config.h: No such file or directory
     #include "config.h"
                        ^
    compilation terminated.
    3rdparty/ccan/ccan/tap/tap.c:26:20: fatal error: config.h: No such file or directory
     #include "config.h"
                        ^
    compilation terminated.
    Makefile:99: recipe for target 'bigfile/tests/test_virtmem.t' failed
    make: *** [bigfile/tests/test_virtmem.t] Error 1

In NumPy, ndarray has .resize() but actually it does a whole array
copy into newly allocated larger segment which makes e.g. appending O(n).

For BigArray, we don't have that internal constraint NumPy has - to
keep the array itself contiguously _stored_ (compare to contiguously
_presented_ in memory). So we can have O(1) resize for big arrays.

NOTE having O(1) resize, here is how O(δ) append can be done:

    A                               # ZBigArray e.g. of shape   (N, 3)
    n = len(A)                      # lengh of A's major index  =N
    A.resize((n+δ, A.shape[1:]))    # add δ new entries ; now len(A) =N+δ
    A[-δ:] = <new-data>             # set data for last new δ entries

/cc @klaus

test_bigarray_indexing_Nd() contains useful class to have a BigFile
connected to ndarray storage. Factor it out so that all tests could use
it.

BigFile_Data.storeblk() is newly introduced and is currently unused, but
will be convenient to have later.