Method SliceGrouping

catboost/cuda/gpu_data/samples_grouping_gpu.cpp:49–100

    }

    TGpuSamplesGrouping<NCudaLib::TMirrorMapping>
    TGpuSamplesGroupingHelper<NCudaLib::TMirrorMapping>::SliceGrouping(const TGpuSamplesGrouping<NCudaLib::TMirrorMapping>& grouping,
                                                                       const TSlice& localSlice) {
        CB_ENSURE(localSlice.Size() <= grouping.CurrentDocsSlice.Size());
        TSlice globalSlice;
        globalSlice.Left = localSlice.Left + grouping.CurrentDocsSlice.Left;
        globalSlice.Right = localSlice.Right + grouping.CurrentDocsSlice.Left;

        const ui32 firstGroupId = grouping.Grouping->GetQueryId(globalSlice.Left);
        const ui32 lastGroupId = grouping.Grouping->GetQueryId(globalSlice.Right);

        const ui32 firstGroupDoc = grouping.Grouping->GetQueryOffset(firstGroupId);
        const ui32 lastGroupDoc = grouping.Grouping->GetQueryOffset(lastGroupId);

        CB_ENSURE(firstGroupDoc == globalSlice.Left, "Error: slice should be group-consistent");
        CB_ENSURE(lastGroupDoc == globalSlice.Right, "Error: slice should be group-consistent");

        auto biases = NCudaLib::GetCudaManager().CreateDistributedObject<ui32>(0);
        for (ui32 dev = 0; dev < biases.DeviceCount(); ++dev) {
            biases.Set(dev, firstGroupDoc);
        }

        TSlice groupsSlice;
        const ui32 groupOffset = grouping.Grouping->GetQueryId(grouping.CurrentDocsSlice.Left);
        CB_ENSURE(firstGroupId >= groupOffset);
        groupsSlice.Left = firstGroupId - groupOffset;
        groupsSlice.Right = lastGroupId - groupOffset;
        CB_ENSURE(grouping.Offsets.GetObjectsSlice() == TSlice(0, grouping.Grouping->GetQueryId(
                                                                      grouping.CurrentDocsSlice.Right) -
                                                                      groupOffset));

        TGpuSamplesGrouping<NCudaLib::TMirrorMapping> sliceGrouping(grouping.Grouping,
                                                                    globalSlice,
                                                                    grouping.Offsets.SliceView(groupsSlice),
                                                                    grouping.Sizes.SliceView(groupsSlice),
                                                                    std::move(biases));
        {
            const TQueriesGrouping* pointwiseSamplesGrouping = dynamic_cast<const TQueriesGrouping*>(grouping.Grouping);
            if (pointwiseSamplesGrouping && pointwiseSamplesGrouping->GetFlatQueryPairs().size()) {
                TSlice pairsSlice;
                CB_ENSURE(firstGroupId >= groupOffset);
                const ui32 shift = pointwiseSamplesGrouping->GetQueryPairOffset(groupOffset);
                pairsSlice.Left = pointwiseSamplesGrouping->GetQueryPairOffset(firstGroupId) - shift;
                pairsSlice.Right = pointwiseSamplesGrouping->GetQueryPairOffset(lastGroupId) - shift;

                sliceGrouping.Pairs = grouping.Pairs.SliceView(pairsSlice);
                sliceGrouping.PairsWeights = grouping.PairsWeights.SliceView(pairsSlice);
            }
        }

        return sliceGrouping;
    }

    TGpuSamplesGrouping<NCudaLib::TStripeMapping> TGpuSamplesGroupingHelper<NCudaLib::TMirrorMapping>::MakeStripeGrouping(const TGpuSamplesGrouping<NCudaLib::TMirrorMapping>& mirrorMapping,
                                                                                                                          const TCudaBuffer<const ui32, NCudaLib::TStripeMapping>& indices) {