[MKLDNN] unint64_t overflow with operator_common.h hashing

[cfRod]

Hi,

While working on issue (#20265).

I have noticed that hash values are overflowing uint64_t. I am working on the following code snippet from (https://github.com/apache/incubator-mxnet/blob/3480ba2c6df02bb907d3a975d354efa8697c4e71/tests/python/unittest/test_operator.py#L1707) where dim is fixed to 2 and num_groups = 2.

@with_seed()
def test_convolution_grouping():
    for dim in [2]:
        num_filter = 4
        for num_group in [2]:
            kernel = (3,) * dim
            shape = (1, 4) + (9,) * dim

            x = mx.sym.Variable('x')
            w = mx.sym.Variable('w')
            b = mx.sym.Variable('b')
            y1 = mx.sym.Convolution(data=x, weight=w, bias=b, num_filter=num_filter, num_group=num_group, kernel=kernel)
            xslice = mx.sym.SliceChannel(data=x, num_outputs=num_group, axis=1)
            wslice = mx.sym.SliceChannel(data=w, num_outputs=num_group, axis=0)
            bslice = mx.sym.SliceChannel(data=b, num_outputs=num_group, axis=0)
            y2 = mx.sym.Concat(*[mx.sym.Convolution(data=xslice[i], weight=wslice[i], bias=bslice[i],
                                                    num_filter=num_filter//num_group, kernel=kernel)
                            for i in range(num_group)])

            exe1 = y1.simple_bind(default_context(), x=shape)
            exe2 = y2.simple_bind(default_context(), x=shape, w=(num_filter, shape[1]//num_group) + kernel, b=(num_filter,))
            for arr1, arr2 in zip(exe1.arg_arrays, exe2.arg_arrays):
                arr1[:] = np.float32(np.random.normal(size=arr1.shape))
                arr2[:] = arr1
            exe1.forward(is_train=True)
            exe1.backward(exe1.outputs[0])
            exe2.forward(is_train=True)
            exe2.backward(exe2.outputs[0])

            for arr1, arr2 in zip(exe1.outputs + exe1.grad_arrays, exe2.outputs + exe2.grad_arrays):
                np.testing.assert_allclose(arr1.asnumpy(), arr2.asnumpy(), rtol=1e-3, atol=1e-3)

Hash computation is done here: https://github.com/apache/incubator-mxnet/blob/3480ba2c6df02bb907d3a975d354efa8697c4e71/src/operator/nn/mkldnn/mkldnn_convolution.cc#L387

MKLDNNConvSignature key(param.conv_param); hash value: 987925020565012126
key.AddSign(is_train); hash value:  1975850041130024253
key.AddSign(data);
->   
void AddSign(const NDArray &arr) {    
     hash = hash * 2 + arr.dtype() hash value: 3951700082260048506 
...
->
void AddSign(const mxnet::TShape &shape) {
   for (int i = 0; i < shape.ndim(); i++) {
      hash = hash * 2 + shape[i]; 
...
}

Values of hashes at each iteration: 7903400164520097013 -> 15806800329040194030 ->13166856584370836453

I think the last hash value actually overflows because if you compute the hash manually it should be 15806800329040194030 * 2 + 9 ~ 3.1613601e+19 where 3.1613601e+19 > UINT64_MAX.

I was wondering if this overflow is a known behaviour?

Thanks,
Crefeda