mirror of
https://gitee.com/milvus-io/milvus.git
synced 2025-12-29 06:55:27 +08:00
114 lines
3.0 KiB
C++
114 lines
3.0 KiB
C++
// Licensed to the LF AI & Data foundation under one
|
|
// or more contributor license agreements. See the NOTICE file
|
|
// distributed with this work for additional information
|
|
// regarding copyright ownership. The ASF licenses this file
|
|
// to you under the Apache License, Version 2.0 (the
|
|
// "License"); you may not use this file except in compliance
|
|
// with the License. You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include "log/Log.h"
|
|
INITIALIZE_EASYLOGGINGPP
|
|
|
|
#include <chrono>
|
|
#include <cstdarg>
|
|
#include <cstdio>
|
|
#include <memory>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
|
|
// namespace milvus {
|
|
|
|
std::string
|
|
LogOut(const char* pattern, ...) {
|
|
size_t len = strnlen(pattern, 1024) + 256;
|
|
auto str_p = std::make_unique<char[]>(len);
|
|
memset(str_p.get(), 0, len);
|
|
|
|
va_list vl;
|
|
va_start(vl, pattern);
|
|
vsnprintf(str_p.get(), len, pattern, vl); // NOLINT
|
|
va_end(vl);
|
|
|
|
return std::string(str_p.get());
|
|
}
|
|
|
|
void
|
|
SetThreadName(const std::string& name) {
|
|
// Note: the name cannot exceed 16 bytes
|
|
pthread_setname_np(pthread_self(), name.c_str());
|
|
}
|
|
|
|
std::string
|
|
GetThreadName() {
|
|
std::string thread_name = "unamed";
|
|
char name[16];
|
|
size_t len = 16;
|
|
auto err = pthread_getname_np(pthread_self(), name, len);
|
|
if (not err) {
|
|
thread_name = name;
|
|
}
|
|
|
|
return thread_name;
|
|
}
|
|
|
|
int64_t
|
|
get_now_timestamp() {
|
|
auto now = std::chrono::system_clock::now().time_since_epoch();
|
|
return std::chrono::duration_cast<std::chrono::seconds>(now).count();
|
|
}
|
|
|
|
int64_t
|
|
get_system_boottime() {
|
|
FILE* uptime = fopen("/proc/uptime", "r");
|
|
float since_sys_boot, _;
|
|
auto ret = fscanf(uptime, "%f %f", &since_sys_boot, &_);
|
|
fclose(uptime);
|
|
if (ret != 2) {
|
|
throw std::runtime_error("read /proc/uptime failed.");
|
|
}
|
|
return static_cast<int64_t>(since_sys_boot);
|
|
}
|
|
|
|
int64_t
|
|
get_thread_starttime() {
|
|
int64_t tid = gettid();
|
|
int64_t pid = getpid();
|
|
char filename[256];
|
|
snprintf(filename, sizeof(filename), "/proc/%ld/task/%ld/stat", pid, tid);
|
|
|
|
int64_t val = 0;
|
|
char comm[16], state;
|
|
FILE* thread_stat = fopen(filename, "r");
|
|
auto ret = fscanf(thread_stat, "%ld %s %s ", &val, comm, &state);
|
|
for (auto i = 4; i < 23; i++) {
|
|
ret = fscanf(thread_stat, "%ld ", &val);
|
|
if (i == 22) {
|
|
break;
|
|
}
|
|
}
|
|
fclose(thread_stat);
|
|
if (ret != 1) {
|
|
throw std::runtime_error("read " + std::string(filename) + " failed.");
|
|
}
|
|
return val / sysconf(_SC_CLK_TCK);
|
|
}
|
|
|
|
int64_t
|
|
get_thread_start_timestamp() {
|
|
try {
|
|
return get_now_timestamp() - get_system_boottime() + get_thread_starttime();
|
|
} catch (...) {
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
// } // namespace milvus
|