Function RunReshardTest

catboost/cuda/cuda_lib/ut/test_cuda_buffer.cpp:433–497

    }

    inline void RunReshardTest(NCudaLib::TCudaManager & manager, bool useCompress = false) {
        TRandom rng(0);
        if (manager.GetDeviceCount() > 1) {
            const ui64 count = 1 << 25;
            const ui64 objectSize = 3;

            auto singleMapping = TSingleMapping(1, count, objectSize);
            auto singleMappingOtherDev = TSingleMapping(0, count, objectSize);
            auto mirrorMapping = TMirrorMapping(count, objectSize);
            auto stripeMapping = TStripeMapping::SplitBetweenDevices(count, objectSize);
            auto anotherStripeMapping = SplitBetweenDevicesRandom(rng, count, objectSize);

            TVector<float> reference;
            for (ui64 i = 0; i < count * objectSize; ++i) {
                reference.push_back(((i * count + objectSize) % 10050) * 1.0f);
            }

            auto bufferSingle = TSingleBuffer<float>::Create(singleMapping);
            auto bufferSingleOtherDev = TSingleBuffer<float>::Create(singleMappingOtherDev);
            auto bufferStripe = TStripeBuffer<float>::Create(stripeMapping);
            auto bufferMirror = TMirrorBuffer<float>::Create(mirrorMapping);
            auto bufferStripeRandom = TStripeBuffer<float>::Create(anotherStripeMapping);

            bufferSingle.CreateWriter(reference).Write();

            //single -> mirror -> stripe -> stripe -> single
            {
                FillBuffer(bufferMirror, 1.0f);
                Reshard(bufferSingle, bufferMirror);
                Validate(reference, bufferMirror);
                for (ui32 i = 0; i < NCudaLib::GetCudaManager().GetDeviceCount(); ++i) {
                    Validate(reference, bufferMirror.DeviceView(i));
                }
                FillBuffer(bufferStripe, 10.0f);
                Reshard(bufferMirror, bufferStripe, 0u, useCompress);
                Validate(reference, bufferStripe);
                //
                FillBuffer(bufferStripeRandom, 100.0f);
                Reshard(bufferStripe, bufferStripeRandom, 0u, useCompress);
                Validate(reference, bufferStripeRandom);
                //
                FillBuffer(bufferSingleOtherDev, 1000.0f);
                Reshard(bufferStripeRandom, bufferSingleOtherDev, 0u, useCompress);
                Validate(reference, bufferSingleOtherDev);
            }

            //single -> single -> stripe -> mirror
            {
                FillBuffer(bufferSingleOtherDev, 1.0f);
                Reshard(bufferSingle, bufferSingleOtherDev, 0u, useCompress);
                Validate(reference, bufferSingleOtherDev);

                FillBuffer(bufferStripe, 1.0f);
                Reshard(bufferSingleOtherDev, bufferStripe, 0u, useCompress);
                Validate(reference, bufferStripe);

                FillBuffer(bufferMirror, 1.0f);
                Reshard(bufferStripe, bufferMirror, 0u, useCompress);