Fix some function names to CamelCase (#770)

* Fix some function names to CamelCase
* Fix typo in README

Author: kanvi-nervana

README.md

@@ -148,7 +148,7 @@ See [this README](/tools) if you want to use Docker.
 ## Classify an image
 
 Once you have installed nGraph bridge, you can use TensorFlow to train a neural network or run inference using a trained model.
-The only change required to a scipt is adding
+The only change required to a script is adding
 
     import ngraph_bridge
 

ngraph_bridge/backend.cc

@@ -39,12 +39,12 @@ Backend::Backend(const string& config) {
   m_device = config;
 }
 
-shared_ptr<Executable> Backend::compile(shared_ptr<ngraph::Function> func,
+shared_ptr<Executable> Backend::Compile(shared_ptr<ngraph::Function> func,
                                         bool) {
   return make_shared<Executable>(func, m_device);
 }
 
-bool Backend::is_supported(const Node& node) const {
+bool Backend::IsSupported(const Node& node) const {
   // TODO: check if the given backend/device supports the op. Right now we're
   // assuming
   // that the selected backend supports all opset5 ops

ngraph_bridge/backend.h

@@ -34,9 +34,9 @@ class Backend {
   Backend(const string& configuration_string);
   ~Backend() {}
 
-  shared_ptr<Executable> compile(shared_ptr<ngraph::Function> func,
+  shared_ptr<Executable> Compile(shared_ptr<ngraph::Function> func,
                                  bool enable_performance_data = false);
-  bool is_supported(const ngraph::Node& node) const;
+  bool IsSupported(const ngraph::Node& node) const;
 
  private:
   string m_device;

ngraph_bridge/executable.cc

@@ -147,12 +147,12 @@ Executable::Executable(shared_ptr<Function> func, string device)
   m_infer_req = exe_network.CreateInferRequest();
 }
 
-bool Executable::call(const vector<shared_ptr<runtime::Tensor>>& inputs,
+bool Executable::Call(const vector<shared_ptr<runtime::Tensor>>& inputs,
                       vector<shared_ptr<runtime::Tensor>>& outputs) {
   if (m_trivial_fn) {
     NGRAPH_VLOG(2) << "Calling trivial IE function with inputs="
                    << inputs.size() << " outputs=" << outputs.size();
-    return call_trivial(inputs, outputs);
+    return CallTrivial(inputs, outputs);
   }
 
   // Check if the number of inputs that the CNN network expects is equal to the
@@ -236,8 +236,8 @@ bool Executable::call(const vector<shared_ptr<runtime::Tensor>>& inputs,
   return true;
 }
 
-bool Executable::call_trivial(const vector<shared_ptr<runtime::Tensor>>& inputs,
-                              vector<shared_ptr<runtime::Tensor>>& outputs) {
+bool Executable::CallTrivial(const vector<shared_ptr<runtime::Tensor>>& inputs,
+                             vector<shared_ptr<runtime::Tensor>>& outputs) {
   // outputs are in the same order as results
   auto results = m_trivial_fn->get_results();
   if (outputs.size() == 0 && results.size() > 0) {

ngraph_bridge/executable.h

@@ -34,16 +34,16 @@ class Executable {
  public:
   Executable(shared_ptr<ngraph::Function> func, string device);
   ~Executable() {}
-  bool call(const vector<shared_ptr<ngraph::runtime::Tensor>>& inputs,
+  bool Call(const vector<shared_ptr<ngraph::runtime::Tensor>>& inputs,
             vector<shared_ptr<ngraph::runtime::Tensor>>& outputs);
 
-  const ngraph::ResultVector& get_results() {
+  const ngraph::ResultVector& GetResults() {
     return m_function->get_results();
   };
 
  private:
-  bool call_trivial(const vector<shared_ptr<ngraph::runtime::Tensor>>& inputs,
-                    vector<shared_ptr<ngraph::runtime::Tensor>>& outputs);
+  bool CallTrivial(const vector<shared_ptr<ngraph::runtime::Tensor>>& inputs,
+                   vector<shared_ptr<ngraph::runtime::Tensor>>& outputs);
 
   InferenceEngine::CNNNetwork m_network;
   InferenceEngine::InferRequest m_infer_req;

ngraph_bridge/kernels/ngraph_encapsulate_op.cc

@@ -262,7 +262,7 @@ void NGraphEncapsulateOp::Compute(OpKernelContext* ctx) {
 
   // Allocate tensors for the output results.
 
-  auto results = ng_exec->get_results();
+  auto results = ng_exec->GetResults();
   std::vector<shared_ptr<ngraph::runtime::Tensor>> ng_outputs(results.size(),
                                                               nullptr);
   std::vector<int> dyn_shape_tensors;
@@ -315,7 +315,7 @@ void NGraphEncapsulateOp::Compute(OpKernelContext* ctx) {
           << "NGraphEncapsulateOp::Compute call starting for cluster "
           << m_cluster_id;
       try {
-        ng_exec->call(ng_inputs, ng_outputs);
+        ng_exec->Call(ng_inputs, ng_outputs);
       } catch (const std::exception& exp) {
         string status_string = "Caught exception while executing cluster " +
                                to_string(m_cluster_id) + ": " +
@@ -433,7 +433,7 @@ Status NGraphEncapsulateOp::GetExecutable(
 
     NG_TRACE("Compile nGraph", m_name, "");
     try {
-      ng_exec = backend->compile(ng_function);
+      ng_exec = backend->Compile(ng_function);
     } catch (const std::exception& ex) {
       return errors::Internal("Failed to compile function " + m_name + ": ",
                               ex.what());

ngraph_bridge/ngraph_mark_for_clustering.cc

@@ -189,7 +189,7 @@ Status IsSupportedByBackend(
   // Loop through the ngraph op list to query
   for (auto it = ng_op->second.begin(); it != ng_op->second.end(); it++) {
     // Pass ngraph node to check if backend supports this op
-    auto ret = op_backend->is_supported(**it);
+    auto ret = op_backend->IsSupported(**it);
     if (!ret) {
       is_supported = false;
       return Status::OK();

test/test_ngraph_exec.cpp

@@ -185,9 +185,9 @@ TEST_F(NGraphExecTest, Axpy) {
   t_y->write(&v_x, sizeof(v_x));
 
   // Execute the nGraph function.
-  auto exec = backend->compile(ng_function);
+  auto exec = backend->Compile(ng_function);
   vector<shared_ptr<ng::runtime::Tensor>> outputs;
-  exec->call({t_x, t_y}, outputs);
+  exec->Call({t_x, t_y}, outputs);
 
   for (size_t i = 0; i < ng_function->get_output_size(); i++) {
     DumpNGTensor<float>(cout, ng_function->get_output_op(i)->get_name(),
@@ -240,9 +240,9 @@ TEST_F(NGraphExecTest, Axpy8bit) {
   t_y->write(&v_x, sizeof(v_x));
 
   // Execute the nGraph function.
-  auto exec = backend->compile(ng_function);
+  auto exec = backend->Compile(ng_function);
   vector<shared_ptr<ng::runtime::Tensor>> outputs;
-  exec->call({t_x, t_y}, outputs);
+  exec->Call({t_x, t_y}, outputs);
 
   for (size_t i = 0; i < ng_function->get_output_size(); i++) {
     DumpNGTensor<int8>(cout, ng_function->get_output_op(i)->get_name(),