Start including stats code in flake8 run

See merge request !55

Fix inames to dup stateful mess

See merge request !57

Fix frozenset construction in test

@mattwala introduced this by copying my MWE... Sorry for the trap.

See merge request !56

check_that_temporaries_are_defined_in_subkernels_where_used(): Respect

aliasing (closes inducer/loopy#69).

Enable running Flake8 during CI

See merge request !48

Add extra error detection related to save_and_reload_temporaries

Fixes #9, #10, and expands the tutorial

See merge request !50

Loop bound codegen fixes

Three somewhat unrelated fixes.
1. Uses PwAff.is_equal() to check if lbound = ubound
2. Gists against implemented domain when finding bounds
3. Keeps track of implemented bounds more accurately

See merge request !53

were implemented.

The issue comes from the fact that a loop bound predicated on a
parameter such as

[n] -> { [(-1 + n - floor((3n)/4))] : n > 0 }

(which may result from slabbing) will be converted by pw_aff_to_expr()
to an unconditional expression, even though the original pw aff is
conditional. As a result the previous code might not actually ensure
that n > 0.

(In prior versions the issue was masked by taking the gist against
dom_and_slab, which would remove the constraint that n > 0.)

The fix is to teach the code about the actual bounds that get
implemented.

equality.

Temporaries with initializer are const

Related: !50

See merge request !52

to be read only.

read-only.

This restriction previously applied to global temporaries.

Elif else updates

Migrating pull request from https://github.com/inducer/loopy/pull/65 to gitlab by request

Note: issue brought up on github is still open:

@inducer there is a bug in here I can't quite figure out.  In the test added in 8e8bd1d0, the generated wrapper reads as:

```
def _lpy_host_loopy_kernel(_lpy_cl_kernels, queue, a, wait_for=None, allocator=None):
    from struct import pack as _lpy_pack
    import pyopencl as _lpy_cl
    import pyopencl.tools

    if allocator is None:
        allocator = _lpy_cl_tools.DeferredAllocator(queue.context)


    _global_temporaries = []

    if (i % 2) == 0:
        pass
        # {{{ enqueue loopy_kernel

        _lpy_knl = _lpy_cl_kernels.loopy_kernel
        assert _lpy_knl.num_args == 1

        pass
        _lpy_knl.set_arg(0, a)
        _lpy_evt = _lpy_cl.enqueue_nd_range_kernel(queue, _lpy_knl, (1,), (1,),  wait_for=wait_for, g_times_l=True)
        wait_for = [_lpy_evt]

        # }}}


    for _tv in _global_temporaries:
        _tv.release()

    return _lpy_evt
```

Note the `if (i %2) == 0:` in there!  `i` is not defined, this causes an error on execution, I am not sure how it get introduced into the wrapper at all.

Note that the test isn't fully correct either (I didn't bother to finish it as I couldn't figure out where the wrapper error was coming from)

See merge request !43

initialize first entries on the if_stack to have the correct insn_predicates in case it's immediately popped off

Dealing with large kernels

See merge request !51