Method RunIteration

catboost/cuda/cuda_lib/gpu_single_worker.cpp:49–152

    }

    bool TGpuOneDeviceWorker::RunIteration() {
        bool shouldStop = false;
        try {
            const bool hasRunning = CheckRunningTasks();
            const bool isEmpty = InputTaskQueue.IsEmpty();

            while (TempMemoryAllocatedObjects.size()) {
                ObjectsToFree.push_back(std::move(TempMemoryAllocatedObjects.back()));
                TempMemoryAllocatedObjects.pop_back();
            }

            if (!hasRunning && isEmpty) {
                InputTaskQueue.Wait(TDuration::Max());
            } else if (!isEmpty) {
                THolder<ICommand> task = InputTaskQueue.Dequeue();

                if (task->GetCommandType() == ECommandType::SerializedCommand) {
                    task = reinterpret_cast<TSerializedCommand*>(task.Get())->Deserialize();
                }

                switch (task->GetCommandType()) {
                    case ECommandType::Reset: {
                        TResetCommand* init = dynamic_cast<TResetCommand*>(task.Get());
                        WaitSubmitAndSync();
                        Reset(*init);
                        break;
                    }
                    //could be run async
                    case ECommandType::StreamKernel: {
                        THolder<IGpuKernelTask> kernelTask(reinterpret_cast<IGpuKernelTask*>(task.Release()));
                        const ui32 streamId = kernelTask->GetStreamId();
                        if (streamId == 0) {
                            WaitAllTaskToSubmit();
                            SyncActiveStreams(true);
                            if (ObjectsToFree.size()) {
                                DeleteObjects();
                                SyncStream(0);
                            }
                        }
                        auto& stream = *Streams[streamId];
                        THolder<NKernel::IKernelContext> data;
                        data = kernelTask->PrepareExec(TempMemoryManager);

                        stream.AddTask(std::move(kernelTask), std::move(data));
                        break;
                    }
                    //synchronized on memory defragmentation
                    case ECommandType::MemoryAllocation: {
                        IAllocateMemoryTask* memoryTask = reinterpret_cast<IAllocateMemoryTask*>(task.Get());
                        AllocateMemory(*memoryTask);
                        break;
                    }
                    case ECommandType::MemoryDeallocation: {
                        THolder<IFreeMemoryTask> freeMemoryTask(reinterpret_cast<IFreeMemoryTask*>(task.Release()));
                        ObjectsToFree.push_back(std::move(freeMemoryTask));
                        WaitSubmitAndSync();
                        break;
                    }