TF_source ) OpKernelRegistrar

"CODE"

 

///op_kernel.cc :: Kernel registration

struct KernelRegistration {
  KernelRegistration(const KernelDef& d, StringPiece c,
                     kernel_factory::OpKernelRegistrar::Factory f)
      : def(d), kernel_class_name(std::string(c)), factory(f) {}
  const KernelDef def;
  const string kernel_class_name;
  const kernel_factory::OpKernelRegistrar::Factory factory;
};

// This maps from 'op_type' + DeviceType to the set of KernelDefs and
// factory functions for instantiating the OpKernel that matches the
// KernelDef.
typedef std::unordered_multimap<string, KernelRegistration> KernelRegistry;

void* GlobalKernelRegistry() {
  static KernelRegistry* global_kernel_registry = new KernelRegistry;
  return global_kernel_registry;
}

static KernelRegistry* GlobalKernelRegistryTyped() {
  return reinterpret_cast<KernelRegistry*>(GlobalKernelRegistry());
}

static string Key(StringPiece op_type, const DeviceType& device_type,
                  StringPiece label) {
  return strings::StrCat(op_type, ":", DeviceTypeString(device_type), ":",
                         label);
}

 

 

/// op_kernel.h :: class OpKernelRegistrar 

namespace kernel_factory {

class OpKernelRegistrar {
 public:
  typedef OpKernel* (*Factory)(OpKernelConstruction*);
                      
  OpKernelRegistrar(const KernelDef* kernel_def, StringPiece kernel_class_name,
                    Factory factory) {
    // Perform the check in the header to allow compile-time optimization
    // to a no-op, allowing the linker to remove the kernel symbols.
    if (kernel_def != nullptr) {
      InitInternal(kernel_def, kernel_class_name, factory);
    }
  } 
 private:
  void InitInternal(const KernelDef* kernel_def, StringPiece kernel_class_name,
                    Factory factory);
};} 

 

 

/// op_kernel.cc :: class OpKernelRegistrar 

namespace kernel_factory {

void OpKernelRegistrar::InitInternal(const KernelDef* kernel_def,
                                     StringPiece kernel_class_name,
                                     Factory factory) {
  // See comments in register_kernel::Name in header for info on _no_register.
  if (kernel_def->op() != "_no_register") {
    const string key =
        Key(kernel_def->op(), DeviceType(kernel_def->device_type()),
            kernel_def->label());
    GlobalKernelRegistryTyped()->insert(std::make_pair(
        key, KernelRegistration(*kernel_def, kernel_class_name, factory))); 
  }
  delete kernel_def; 
}}

 

 

"CONCLUSION"

 

Class OpKernelRegister

         Constructor ( KernelDef* , StringPiece, Factory)             

                         if KernelDef* argument isn't null 

                              -> call InitInternal function

 

void InitInternal(KernelDef*, StringPiece, Factory) 

    if kernel_def->op() != "_no_register"

      -> make string key, that denote "Op_type , device type, label "

      -> make pair with key & kernelRegistration. And insert into KernelRegistry,

        which is type defined unordered_multimap < string : key , type : KernelRegistration > 

                                

struct  KernelRegistration

  const KernelDef def

  const string kernel_class_name

  const kernel_factory::OpKernelRegistrar::Factory factory

 

 

"REF"

microsoft Docs :: unordered_multimap

https://docs.microsoft.com/ko-kr/cpp/standard-library/unordered-multimap-class?view=vs-2019

 

cppreference :: make_pair

https://en.cppreference.com/w/cpp/utility/pair/make_pair

 

 

"NEXT"

-Factory

-KernelDef