Refactor: Alternative implementations for dependencies from Thunder

[AdityaKasar]

No description provided.

[CLAassistant]

All committers have signed the CLA.

[tomasz-blasz]

In case when a given CLASS is not defined within a namespace, the function returns empty string as a name:

namespace abc
{
  class Test_abc {};
}
class Test_glob {};

int main()
{
  printf("[%s]\n", Module<abc::Test_abc>().c_str());
  printf("[%s]\n", Module<Test_glob>().c_str());
}

# output:
[Test_abc]
[]

[tomasz-blasz]

There is no reason for 3 separate variables: demangled_name, method_name, full_name. The function can be simplified into

template <typename CLASS>
static const std::string Module()
{
    char _name[512];
    size_t _size = sizeof(_name) - 1;
    std::string class_name = abi::__cxa_demangle(typeid(CLASS).name(), _name, &_size, 0);
    std::size_t last_colon = class_name.rfind("::");
    if (last_colon != std::string::npos) {
        class_name = class_name.substr(last_colon + 2);
    }
    return class_name;
}

Proposed version has already a fix for a class outside of any namesapece:

namespace abc
{
  class Test_abc {};
}
class Test_glob {};

int main()
{
  printf("[%s]\n", Module<abc::Test_abc>().c_str());
  printf("[%s]\n", Module<Test_glob>().c_str());
}

# output:
[Test_abc]
[Test_glob]

[tomasz-blasz]

No strong opinion here, just a thought that using C to obtain current time would speed up the function ~3 times in average: from 50ns to 17ns per call (on Ubuntu PC), it could be significant in logging functions on embedded device but does not have to, depending on how many logs are being produced.

char* GetTime__c(char *s, size_t len)
{
    time_t t = time(NULL);
    strftime(s, len, "%H:%M:%S", localtime(&t));
    return s;
}

Evaluation:

int main()
{
  const char *s1;

  constexpr size_t s2_size = 10;
  char s2[s2_size];

  std::chrono::steady_clock::time_point t1;
  std::chrono::steady_clock::time_point t2;

  long unsigned duration1 = 0;
  long unsigned duration2 = 0;

  constexpr unsigned count = 10;
  for (unsigned i = 0; i < count; ++i) {
    t1 = std::chrono::steady_clock::now();
    s1 = GetCurrentTime24HoursFormat().c_str();
    t2 = std::chrono::steady_clock::now();
    duration1 += std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
    printf("t - cpp[%02u]: %s\n", i, s1);
    std::this_thread::sleep_for(std::chrono::milliseconds(250));
  }
  for (unsigned i = 0; i < count; ++i) {
    t1 = std::chrono::steady_clock::now();
    GetTime__c(s2, s2_size);
    t2 = std::chrono::steady_clock::now();
    duration2 += std::chrono::duration_cast<std::chrono::nanoseconds>(t2 - t1).count();
    printf("t - c  [%02u]: %s\n", i, s2);
    std::this_thread::sleep_for(std::chrono::milliseconds(250));
  }
  printf("t - cpp    : count: %u, duration-total: %7luns, avg-duration: %6luns\n", count, duration1, duration1/count);
  printf("t - c      : count: %u, duration-total: %7luns, avg-duration: %6luns\n", count, duration2, duration2/count);

  return 0;
}

# output:
t - cpp[00]: 15:16:58
...
t - cpp[09]: 15:17:00
t - c  [00]: 15:17:00
...
t - c  [09]: 15:17:03
t - cpp    : count: 10, duration-total:  529668ns, avg-duration:  52966ns
t - c      : count: 10, duration-total:  175083ns, avg-duration:  17508ns