Native extension to bind to cccl c parallel library - #4325

The state_type was added in NVIDIAgh-4325

* Add Cython extension that implements bindings

* Native extension for launching reduce_into algorithm

It is as fast as ctypes, also needs to redeclare structs,
but in Cython.

Using the following script to compare time of submission
using ctypes-based and using Cython-based approaches

```python
import cuda.parallel.experimental.algorithms.reduce as impl_base
import cuda.parallel.experimental.algorithms._cy_reduce as impl_new

import numpy as np
import cupy as cp

import time

def time1(reps):
    global pr
    d = cp.ones(10, dtype="i4")
    res = cp.empty(tuple(), dtype=d.dtype)
    h_init = np.zeros(tuple(), dtype=d.dtype)

    def my_add(a, b):
        return a + b

    alg = impl_new.reduce_into(d, res, my_add, h_init)
    temp_bytes = alg(None, d, res, d.size, h_init)
    scratch = cp.empty(temp_bytes, dtype=cp.uint8)

    t0 = time.perf_counter_ns()
    for i in range(reps):
        alg(scratch, d, res, d.size, h_init)
    t1 = time.perf_counter_ns()

    return t1 - t0

def time2(reps):
    global pr
    d = cp.ones(10, dtype="i4")
    res = cp.empty(tuple(), dtype=d.dtype)
    h_init = np.zeros(tuple(), dtype=d.dtype)

    def my_add(a, b):
        return a + b

    alg = impl_base.reduce_into(d, res, my_add, h_init)
    temp_bytes = alg(None, d, res, d.size, h_init)
    scratch = cp.empty(temp_bytes, dtype=cp.uint8)

    t0 = time.perf_counter_ns()
    for i in range(reps):
        alg(scratch, d, res, d.size, h_init)
    t1 = time.perf_counter_ns()

    return t1 - t0

if __name__ == "__main__":
    print("Base: ", time2(100000))
    print("New:  ", time1(100000))
```

I see

```
(cuda_parallel_venv) (cccl) coder ➜ ~/cccl/python/cuda_parallel $ LD_LIBRARY_PATH=${LD_LIBRARY_PATH}:${VIRTUAL_ENV}/lib/python3.10/site-packages/cuda/parallel/experimental/cccl python bench.py
Base:  454121541
New:   448204824
```

The timings are roughly the same.

* Add bench script and test_cyb.py

* Add steps to build Cython extension to replace ctypes-based bindings

* Introduce static attribute _impl = _cy_bindings

This is to prevent conditions under which the model
`_cy_bindings` had been unloaded before `_Reduce.__del__`
operator has been called resulting in attribute errors
what NoneType does not have device_reduce_cleanup
attribute.

* Add stub file for native extension for mypy linter to pass

* Add cython as build-time dependency of cuda.parallel

* WIP

* Represent state of iterators using IteratorState

State of cuda.parallel.experimental.iterators is stored
as IteratorState class instance.

* Reorder runtime type-check in Pointer constructor to optimize for PointerProxy argument handling

* Bench can time pointer-base workflow and iterator-base workflow

* Add comment about why self._impl is needed

Replaced use of `cyb` module with self._impl

* Add cython-based Scan algorithm

* Add Cython bindings for segmented reduce

* Reduce problem size for uint64 data type reduction test

This avoid out-of-memory exception arising on entry level GPUs

* Add tests for cython-binding of segmented reduce

* Create tests_for_cything_bindings

* Added cython bindings for all existing algorithms

Tests added to exercise cython bindings

* Corrected import

* Introduce _cy_bindings.make_pointer

Replace use of array.__cuda_array_interface__["data"][0] with
protocols.get_pointer

* Remove PointerProxy class

* Initialize enum values in constructor, instead of in property body

This makes the cost of `IteratorKind.POINTER` much lower (no need
to recreate new copy of IntEnum on every call).

Also create two new query methods in Iterator class, `.is_kind_pointer()`
( it is a 3x faster than `it.type == IteratorKind.POINTER` )
and `.is_kind_iterator()`

* Commend out all get() and get_ptr() cdef methods

* Save repeated computation in locals, use slots of _MergeSort class

* Bench scripts

* Delete commented out code, eliminate build result struct member redeclaration

* Make Cython-based implementation default

Legacy implementation is still accessible via cuda.parallel.experimental.algorithms.legacy,
and cuda.parallel.experimental.iterator_legacy

Legacy test suite is still accessible via tests_legacy/

Both `pytest tests` and `pytest tests_legacy` pass.

* Update benchmark scripts for file reorg

* Add device synchronization in benchmark scripts after each bench

* Optimize attribute away lookup out of hot loop

Instead of looking up function from module in __call__,
import it into the implementations' namespace directly.

This shaves a hundrend nanoseconds per instance changed.

* Changed API exposed by Cython

Instead of exposing cccl_device_reduce_build, cccl_device_reduce
and cccl_device_reduce_cleanup which act on build_result struct (C-style),
we expose these actions as methods of Python class that stores the
build_result variable.

The cleanup method is just called by `__dealloc__` special methods
of that class and is never exposed to the user.

* Delete benchmarking scripts and legacy interface

* Release GIL when calling cccl.c.parallel functions

This should be particularly beneficial for build step.

* Drop use of '_cy' prefix in filenames

* Reverse iterator to set state_type parameter of its parent IteratorBase class

* Strenghten test_iterator test checking kind comparison

Test checks whether iteratator's kind compares unequal
for iterators with different value types even though
the values themselves compare equal.

* Add state_value to IteratorKind constructor

IteratorKind's hash values are used to cache compiled programs.
Iterators generating different LTOIR should never hash to the same
value. To ensure that parametric iterators with different parameter
values (for example, 1D strided iterator with different step sizes)
has to different values we must mix state_type into the hash.

For this reason, state_value is now passed to IteratorKind's
constructor along with value_type.

* Address PR feedback

1. Replace use of Cython deprecated syntax for property getter/setter definition
   with conventional @Property and @state.setter decorators
2. Removed IteratorStateView and its uses
3. Added docstring documenting that `as_bytes` are debug utilities to
   obtain memory view of native library structs.
4. Removed unused pointer_as_bytes function in Cython extension

* Removed cy_ prefix from Cython types and redeclarations

This makes it much less verbose and easier to maintain.

* Remove _cccl.py as it creeped back in after rebasing

* add _bindings to mock'd imports

* Remove resources/cmake

Implement cythonization step via add_custom_command instead.
Cython command generates DEPFILE. Custom target is created
to link to the custom commandm. The custom target is added
as dependency of `_bindings` target that generates the extension.

* Addressed feedback from @rwgk review

1. Add comment at the top of _bindings.pyx advising reader of existence
   of _bindings.pyi stub file and the need to keep Python API in sync
   to clear checks of Python's static typing tools, e.g., `mypy`.

2. Renamed native class member in `IteratorState` type from
   `size` (which coincided with Python's property) and misled
   AI agents in believing that infinite recursion is possible.

   The native struct member is now called state_nbytes instead.

* Use cuda_parallel_SOURCE_DIR instead of CMAKE_SOURCE_DIR, use quotes

Also directly require Python3 and use Python3_add_library

* IntEnum -> IntEnumerationMember

* Add missing quote around cmake variable

* Changes to PR review

1. Missing quotes
2. Removed FIND_PACKAGE_HANDLE_STANDARD_ARGS and mark_as_advanced

* Set GENERATED property of Cython-generated source file to TRUE

* Add quotes around Python3_EXECUTABLE

* Use cuda_parallel_BINARY_DIR instead of CMAKE_BINARY_DIR

* Change signature of arg_type_check to have void return type with except *

* Corrected docstring in predicates

* Change signature of alignment validation function to have return type void and qualifier except *

---------

Co-authored-by: Ashwin Srinath <[email protected]>