Class TSplitHelper

catboost/cuda/gpu_data/oblivious_tree_bin_builder.cpp:9–120

        template <class TDataSet,
                  class TCtrSplitBuilder>
        class TSplitHelper: public IBinarySplitProvider {
        public:
            TSplitHelper(TScopedCacheHolder& scopedCache,
                         TCtrSplitBuilder& builder,
                         const TBinarizedFeaturesManager& featuresManager,
                         const TDataSet& dataSet)
                : ScopedCache(scopedCache)
                , CtrSplitBuilder(builder)
                , FeaturesManager(featuresManager)
                , DataSet(dataSet)
            {
            }

            const TMirrorBuffer<ui64>& GetCompressedBits(const TBinarySplit& split) const final {
                const ui32 featureId = split.FeatureId;
                if (DataSet.HasFeatures() && DataSet.GetFeatures().HasFeature(featureId)) {
                    return GetCompressedBitsFromGpuFeatures(DataSet.GetFeatures(), split, nullptr);
                } else if (DataSet.HasPermutationDependentFeatures() && DataSet.GetPermutationFeatures().HasFeature(featureId)) {
                    return GetCompressedBitsFromGpuFeatures(DataSet.GetPermutationFeatures(),
                                                            split,
                                                            &DataSet.GetInverseIndices());
                } else if (FeaturesManager.IsTreeCtr(split.FeatureId)) {
                    return CtrSplitBuilder.ComputeAndCacheCtrSplit(DataSet,
                                                                   split);
                } else {
                    ythrow TCatBoostException() << "Error: unknown feature";
                }
            }

            void Split(const TBinarySplit& split,
                       TMirrorBuffer<ui32>& bins,
                       ui32 depth) final {
                const auto& compressedBits = GetCompressedBits(split);
                UpdateBinFromCompressedBits(compressedBits,
                                            bins,
                                            depth);
            }

            void SplitByExternalComputedFeature(const TBinarySplit& split,
                                                const TSingleBuffer<const ui64>& compressedBits,
                                                TMirrorBuffer<ui32>& dst,
                                                ui32 depth) override {
                CB_ENSURE(FeaturesManager.IsTreeCtr(split.FeatureId), "Feature id should be combinations ctr");

                const auto& ctr = FeaturesManager.GetCtr(split.FeatureId);

                const ui32 docCount = DataSet.GetSamplesMapping().GetObjectsSlice().Size();
                const ui32 compressedSize = CompressedSize<ui64>(docCount, 2);
                auto broadcastFunction = [&]() -> TMirrorBuffer<ui64> {
                    TMirrorBuffer<ui64> broadcastedBits = TMirrorBuffer<ui64>::Create(NCudaLib::TMirrorMapping(compressedSize));
                    Reshard(compressedBits, broadcastedBits);
                    return broadcastedBits;
                };

                const auto& mirrorCompressedBits = [&]() -> const TMirrorBuffer<ui64>& {
                    if (FeaturesManager.IsPermutationDependent(ctr)) {
                        return ScopedCache.Cache(DataSet.GetPermutationDependentScope(),
                                                 split,