Use getattr instead of hasattr

[jakirkham]

Calling hasattr is just as expensive as calling getattr and slightly more expensive than direct attribute access. As a result calling hasattr and then perform attribute access, we are effectively paying the cost of attribute access twice.

hasattr vs. getattr vs. direct access

In [1]: import numpy                                                            

In [2]: a = numpy.arange(110).reshape(10, 11)                                   

In [3]: %timeit hasattr(a, "__array_interface__")                               
1.17 µs ± 3.73 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit getattr(a, "__array_interface__", None)                         
1.17 µs ± 5.61 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [5]: %timeit a.__array_interface__                                           
1.11 µs ± 2.27 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

When we look at the overall runtime of get_buffer_data and get_buffer_nbytes, we can see that attribute access makes a significant contribution to runtime of these functions overall.

Runtime before of get_buffer_data and get_buffer_nbytes

In [1]: import numpy 
   ...:  
   ...: from ucp._libs.utils import get_buffer_data, get_buffer_nbytes          

In [2]: a = numpy.arange(110).reshape(10, 11)                                   

In [3]: %timeit get_buffer_data(a)                                              
2.48 µs ± 12.8 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

In [4]: %timeit get_buffer_nbytes(a, check_min_size=None, cuda_support=True)    
3.67 µs ± 17.2 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

So we can simply switch to getattr and add a default case of None to check for. Overall this is a pretty minor change to the code here. Though the result in terms of get_buffer_data and get_buffer_nbytes is quite notable, making both ~2x faster.

Runtime after of get_buffer_data and get_buffer_nbytes

In [1]: import numpy 
   ...:  
   ...: from ucp._libs.utils import get_buffer_data, get_buffer_nbytes          

In [2]: a = numpy.arange(110).reshape(10, 11)                                   

In [3]: %timeit get_buffer_data(a)                                              
1.16 µs ± 12.6 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [4]: %timeit get_buffer_nbytes(a, check_min_size=None, cuda_support=True)    
2.13 µs ± 20.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

cc @pentschev @madsbk @quasiben

[jakirkham]

Absorbed into PR ( #546 ).