DispatcherHost.h

Go to the documentation of this file.

#ifndef PROTEUS_FRONTEND_DISPATCHER_HOST_H
#define PROTEUS_FRONTEND_DISPATCHER_HOST_H
 
#include "proteus/Frontend/Dispatcher.h"
#include "proteus/TimeTracing.h"
#include "proteus/impl/Caching/MemoryCache.h"
#include "proteus/impl/Caching/ObjectCacheChain.h"
#include "proteus/impl/CompiledLibrary.h"
#include "proteus/impl/Config.h"
#include "proteus/impl/JitEngineHost.h"
 
namespace proteus {
 
class DispatcherHost : public Dispatcher {
public:
  static DispatcherHost &instance() {
    static DispatcherHost D{"DispatcherHost", JitEngineHost::instance()};
    return D;
  }
 
  DispatcherHost(const std::string &Label, JitEngineHost &Jit)
      : Dispatcher(Label, TargetModelType::HOST), Jit(Jit), CodeCache(Label) {}
 
  std::unique_ptr<MemoryBuffer>
  compileModule(Module &M, const CodeGenerationConfig &CGConfig) override {
    TIMESCOPE(DispatcherHost, compileModule);
    return Jit.compileOnly(M, CGConfig);
  }
 
  DispatchResult launch(void *, LaunchDims, LaunchDims, void *[], uint64_t,
                        void *) override {
    reportFatalError("Host does not support launch");
  }
 
  StringRef getDeviceArch() const override {
    reportFatalError("Host dispatcher does not implement getDeviceArch");
  }
 
  void *lookupFunction(StringRef BaseName, const HashT &ModuleHash) override {
    HashT FuncHash = hash(BaseName, ModuleHash);
    return CodeCache.lookup(FuncHash);
  }
 
  void *insertFunction(const KernelName &Name, const HashT &ModuleHash,
                       CompiledLibrary &Library) override {
    TIMESCOPE(DispatcherHost, insertFunction);
    const std::string MangledName = Name.mangled();
    HashT FuncHash = hash(StringRef(Name.base()), ModuleHash);
 
    if (!Library.IsLoaded) {
      Jit.loadCompiledLibrary(Library);
      Library.IsLoaded = true;
    }
 
    void *FuncAddr = Jit.getFunctionAddress(MangledName, Library);
    if (!FuncAddr)
      reportFatalError("Failed to find address for function " + MangledName);
 
    CodeCache.insert(FuncHash, FuncAddr, Name.base());
 
    return FuncAddr;
  }
 
  void registerDynamicLibrary(const HashT &HashValue,
                              const std::string &Path) override {
    auto Buf = MemoryBuffer::getFileAsStream(Path);
    if (!Buf)
      reportFatalError("Failed to read dynamic library: " + Path);
    ObjectCache->store(HashValue,
                       CacheEntry::sharedObject((*Buf)->getMemBufferRef()));
  }
 
  ~DispatcherHost() {
    if (Config::get().traceCacheStats())
      CodeCache.printStats();
    CodeCache.printKernelTrace();
    printObjectCacheStats();
  }
 
protected:
  explicit DispatcherHost(const std::string &Label, JitEngineHost &Jit,
                          TargetModelType TM)
      : Dispatcher(Label, TM), Jit(Jit), CodeCache(Label) {}
 
private:
  JitEngineHost &Jit;
  MemoryCache<void *> CodeCache;
};
 
} // namespace proteus
 
#endif // PROTEUS_FRONTEND_DISPATCHER_HOST_H