text: // Copyright (c) Microsoft Corporation. All rights reserved.
  // Licensed under the MIT License.
  
  #pragma once
  
  #include "LearningModelDevice.g.h"
  
  #include "iengine.h"
  
  namespace _winml {
  class ConverterResourceStore;
  class D3DDeviceCache;
  }  // namespace _winml
  
  namespace WINMLP {
  
  struct LearningModelDevice : LearningModelDeviceT<LearningModelDevice, IMetacommandsController, IDeviceFenceValidator> {
   public:
    LearningModelDevice() = delete;
  
    LearningModelDevice(
        winml::LearningModelDeviceKind const& deviceKind);
  
    LearningModelDevice(
        wgdx::Direct3D11::IDirect3DDevice const& device);
  
    LearningModelDevice(
        ID3D12CommandQueue* queue);
  
    ~LearningModelDevice();
  
    wg::DisplayAdapterId
    AdapterId();
  
    static winml::LearningModelDevice CreateFromDirect3D11Device(
        wgdx::Direct3D11::IDirect3DDevice const& device);
  
    // internal:
    STDMETHOD(SetMetacommandsEnabled)
    (
        boolean enabled) final;
  
    // internal:
    STDMETHOD_(boolean, SharedHandleInitialized)
    ();
  
    STDMETHOD(GetThreadPool)(
          _winml::IThreading** thread_pool);
  
    STDMETHOD(CacheThreadPool)(
          _winml::IThreading* thread_pool);
  
    // internal:
  
    winml::LearningModelDeviceKind
    GetDeviceKind();
  
    bool
    MetacommandsEnabled();
  
    bool
    IsCpuDevice();
  
    const LUID&
    GetDeviceLuid();
  
    _winml::D3DDeviceCache*
    GetD3DDeviceCache();
  
    wgdx::Direct3D11::IDirect3DDevice
    Direct3D11Device();
  
    ID3D12Device*
    GetD3DDevice();
  
    ID3D12CommandQueue*
    GetDeviceQueue();
  
    static void
    DllUnload();
  
    std::shared_ptr<_winml::ConverterResourceStore>
    TensorizerStore();
  
    std::shared_ptr<_winml::ConverterResourceStore>
    DetensorizerStore();
  
    uint32_t
    NumberOfIntraOpThreads();
  
    bool
    AllowSpinning();
  
   private:
    // stores the device kind that was originally chosen in the constructor
    winml::LearningModelDeviceKind m_deviceKind;
    // if the user asked us to run on the cpu, or asked us to choose and we chose cpu
    bool m_isCpuDevice;
    bool m_areMetacommandsEnabled = true;
    std::shared_ptr<_winml::ConverterResourceStore> m_detensorizerStore;
    std::once_flag m_detensorizerStoreInitialized;
    std::shared_ptr<_winml::ConverterResourceStore> m_tensorizerStore;
    std::once_flag m_tensorizerStoreInitialized;
  
    std::unique_ptr<_winml::D3DDeviceCache> m_deviceCache;
  
    com_ptr<_winml::IThreading> m_threadPool;
  };
  }  // namespace WINMLP
  
  namespace WINML::factory_implementation {
  struct LearningModelDevice : LearningModelDeviceT<LearningModelDevice, implementation::LearningModelDevice, ILearningModelDeviceFactoryNative> {
    HRESULT __stdcall CreateFromD3D12CommandQueue(ID3D12CommandQueue* queue, IUnknown** device) noexcept final;
  };
  }  // namespace WINML::factory_implementation
  