blob: 4b19db323a5b0d1d5dcbd4551c89f4936ac0f7be [file] [log] [blame]
// Licensed to the Apache Software Foundation (ASF) 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
// Unless required by applicable law or agreed to in writing,
// software distributed under the License is distributed on an
// KIND, either express or implied. See the License for the
// specific language governing permissions and limitations
// under the License.
#include <string>
#include <sys/syscall.h>
#include <unistd.h>
#include "glog/logging.h"
#include "gutil/macros.h"
#include "gutil/strings/util.h"
#include "util/debug-util.h"
namespace impala {
class ScopedThreadContext;
/// Stores information about the current thread that can be useful in a debug session.
/// An object of this class needs to be allocated on the stack in order to include
/// it in minidumps. While this object is alive, it is available through the global
/// function 'GetThreadDebugInfo()'.
/// During a debug session, locate this object in the core file or in the minidump,
/// then inspect its members.
class ThreadDebugInfo {
/// Only one ThreadDebugInfo object can be alive per thread at a time.
/// This object is not copyable, nor movable
ThreadDebugInfo() {
system_thread_id_ = syscall(SYS_gettid);
// This call makes the global (thread local) pointer point to this object.
~ThreadDebugInfo() {
// Resets the global (thread local) pointer to null.
const TUniqueId& GetQueryId() const { return query_id_; }
const TUniqueId& GetInstanceId() const { return instance_id_; }
const char* GetThreadName() const { return thread_name_; }
int64_t GetSystemThreadId() const { return system_thread_id_; }
int64_t GetParentSystemThreadId() const { return parent_.system_thread_id_; }
const char* GetParentThreadName() const { return parent_.thread_name_; }
/// Saves 'query_id' to member 'query_id_'
void SetQueryId(const TUniqueId& query_id) {
query_id_ = query_id;
/// Saves 'instance_id' to member 'instance_id_'
void SetInstanceId(const TUniqueId& instance_id) {
instance_id_ = instance_id;
/// Saves param 'thread_name' to member 'thread_name_'.
/// If the length of param 'thread_name' is larger than THREAD_NAME_SIZE,
/// we store the front of 'thread_name' + '...' + the last few bytes
/// of thread name, e.g.: "Long Threadname with more te...001afec4)"
void SetThreadName(const std::string& thread_name) {
const int64_t length = thread_name.length();
if (length < THREAD_NAME_SIZE) {
thread_name.copy(thread_name_, length);
} else {
const int64_t tail_length = THREAD_NAME_TAIL_LENGTH;
// 4 is the length of "..." and '\0'
const int64_t front_length = THREAD_NAME_SIZE - tail_length - 4;
// copy 'front_length' sized front of 'thread_name' to 'thread_name_'
thread_name.copy(thread_name_, front_length);
// append "..."
for (int i = 0; i < 3; ++i) thread_name_[front_length + i] = '.';
// append 'tail_length' sized tail of 'thread_name' to 'thread_name_'
thread_name.copy(thread_name_ + front_length + 3, tail_length,
length - tail_length);
void SetParentInfo(const ThreadDebugInfo* parent) {
if (parent == nullptr) return;
parent_.system_thread_id_ = parent->system_thread_id_;
strings::strlcpy(parent_.thread_name_, parent->thread_name_, THREAD_NAME_SIZE);
query_id_ = parent->query_id_;
instance_id_ = parent->instance_id_;
/// Initializes a thread local pointer with thread_debug_info.
static void InitializeThreadDebugInfo(ThreadDebugInfo* thread_debug_info);
/// Resets the thread local pointer to nullptr.
static void CloseThreadDebugInfo();
static constexpr int64_t THREAD_NAME_SIZE = 256;
static constexpr int64_t THREAD_NAME_TAIL_LENGTH = 8;
static const TUniqueId ZERO_THREAD_ID;
/// This struct contains information we want to store about the parent.
struct ParentInfo {
int64_t system_thread_id_ = 0;
char thread_name_[THREAD_NAME_SIZE] = {};
ParentInfo parent_;
int64_t system_thread_id_ = 0;
char thread_name_[THREAD_NAME_SIZE] = {};
// Will be "0" (the default TUniqueId with hi=lo=0) when thread isn't
// part of query or instance execution.
TUniqueId query_id_;
TUniqueId instance_id_;
friend class ScopedThreadContext;
friend class ThreadDebugInfo_Scoping_Test;
/// An RAII-style wrapper to clear thread debug info query and instance
/// context at destruction.
class ScopedThreadContext {
~ScopedThreadContext() {
ScopedThreadContext(ThreadDebugInfo* thread_debug_info, const TUniqueId& query_id,
const TUniqueId& instance_id = ThreadDebugInfo::ZERO_THREAD_ID) {
thread_debug_info_ = thread_debug_info;
ThreadDebugInfo* thread_debug_info_;
/// Returns a pointer to the ThreadDebugInfo object for this thread.
/// Returns nullptr if there is no ThreadDebugInfo object for the current thread.
ThreadDebugInfo* GetThreadDebugInfo();