class StackVisitor {...    [[maybe_unused]] virtual bool VisitFrame();    // preserve for real StackVisitor's fields space    [[maybe_unused]] char mSpaceHolder[2048]; ...};
class StackVisitor {
...
    [[maybe_unused]] virtual bool VisitFrame();
    // preserve for real StackVisitor's fields space
    [[maybe_unused]] char mSpaceHolder[2048]; 
...
};

bool StackVisitor::innerVisitOnce(JavaStack &stack, void *thread, uint64_t *outTime,                                  uint64_t *outCpuTime) {    StackVisitor visitor(stack);    void *vptr = *reinterpret_cast<void **>(&visitor);    // art::Context::Create()    auto *context = sCreateContextCall();    // art::StackVisitor::StackVisitor(art::Thread*, art::Context*, art::StackVisitor::StackWalkKind, bool)    sConstructCall(reinterpret_cast<void *>(&visitor), thread, context, StackWalkKind::kIncludeInlinedFrames, false);    *reinterpret_cast<void **>(&visitor) = vptr;    // void art::StackVisitor::WalkStack<(art::StackVisitor::CountTransitions)0>(bool)    visitor.walk();}
bool StackVisitor::innerVisitOnce(JavaStack &stack, void *thread, uint64_t *outTime,
                                  uint64_t *outCpuTime) {
    StackVisitor visitor(stack);
    void *vptr = *reinterpret_cast<void **>(&visitor);
    // art::Context::Create()
    auto *context = sCreateContextCall();
    // art::StackVisitor::StackVisitor(art::Thread*, art::Context*, art::StackVisitor::StackWalkKind, bool)
    sConstructCall(reinterpret_cast<void *>(&visitor), thread, context, StackWalkKind::
kIncludeInlinedFrames
, false);
    *reinterpret_cast<void **>(&visitor) = vptr;
    // void art::StackVisitor::WalkStack<(art::StackVisitor::CountTransitions)0>(bool)
    visitor.walk();
}

[[maybe_unused]] bool StackVisitor::VisitFrame() {    // art::StackVisitor::GetMethod() const    auto *method = sGetMethodCall(reinterpret_cast<void *>(this));    mStack.mStackMethods[mCurIndex] = uint64_t(method);    mCurIndex++;    return true;}
[[maybe_unused]] bool StackVisitor::VisitFrame() {
    // art::StackVisitor::GetMethod() const
    auto *method = sGetMethodCall(reinterpret_cast<void *>(this));
    mStack.mStackMethods[mCurIndex] = uint64_t(method);
    mCurIndex++;
    return true;
}

class MyAllocationListener : AllocationListener {    ...    void ObjectAllocated(void *self, void **obj, size_t byte_count) override {        // TODO 這里抓棧    }};
class MyAllocationListener : AllocationListener {
    ...
    void ObjectAllocated(void *self, void **obj, size_t byte_count) override {
        // TODO 這里抓棧
    }
};

thread_local uint64_t lastNano = 0;bool SamplingCollector::request(SamplingType type, void *self, bool force, bool captureAtEnd, uint64_t beginNano, uint64_t beginCpuNano, std::function<void(SamplingRecord&)> fn) {    auto currentNano = rheatrace::current_time_nanos();    if (force || currentNano - lastNano > threadCaptureInterval) {        lastNano = currentNano;        ...        if (StackVisitor::visitOnce(r.mStack, self)) {            collector->write(r);            return true;        }    }    return false;}

thread_local uint64_t lastNano = 0;
bool SamplingCollector::request(SamplingType type, void *self, bool force, bool captureAtEnd, uint64_t beginNano, uint64_t beginCpuNano, std::function<void(SamplingRecord&)> fn) {
    auto currentNano = rheatrace::current_time_nanos();
    if (force || currentNano - lastNano > threadCaptureInterval) {
        lastNano = currentNano;
        ...
        if (StackVisitor::visitOnce(r.mStack, self)) {
            collector->write(r);
            return true;
        }
    }
    return false;
}

void Monitor_Lock(void* monitor, void* threadSelf) {SHADOWHOOK_STACK_SCOPE();    rheatrace::ScopeSampling a(rheatrace::stack::SamplingType::kMonitor, threadSelf);SHADOWHOOK_CALL_PREV(Monitor_Lock, monitor, threadSelf);}class ScopeSampling {private:    uint64_t beginNano_;    uint64_t beginCpuNano_;public:    ScopeSampling(SamplingType type, void *self = nullptr, bool force = false) : type_(type), self_(self), force_(force) {        beginNano_ = rheatrace::current_time_nanos();        beginCpuNano_ = rheatrace::thread_cpu_time_nanos();    }    ~ScopeSampling() {        SamplingCollector::request(type_, self_, force_, true, beginNano_, beginCpuNano_);    }};
void Monitor_Lock(void* monitor, void* threadSelf) {
SHADOWHOOK_STACK_SCOPE();
    rheatrace::ScopeSampling a(rheatrace::stack::SamplingType::
kMonitor, threadSelf);
SHADOWHOOK_CALL_PREV
(Monitor_Lock, monitor, threadSelf);
}
class ScopeSampling {
private:
    uint64_t beginNano_;
    uint64_t beginCpuNano_;
public:
    ScopeSampling(SamplingType type, void *self = nullptr, bool force = false) : type_(type), self_(self), force_(force) {
        beginNano_ = rheatrace::current_time_nanos();
        beginCpuNano_ = rheatrace::thread_cpu_time_nanos();
    }
    ~ScopeSampling() {
        SamplingCollector::request(type_, self_, force_, true, beginNano_, beginCpuNano_);
    }
};

# 關(guān)閉sip# 終端登錄root賬號(hào)dtruss -c -p pid # -c表示統(tǒng)計(jì)系統(tǒng)調(diào)用的次數(shù)；
# 關(guān)閉sip
# 終端登錄root賬號(hào)
dtruss -c -p pid # -c表示統(tǒng)計(jì)系統(tǒng)調(diào)用的次數(shù)；

名稱                          次數(shù)ulock_wake                   15346  # unfair lock, unlockulock_wait2                  15283  # unfair lock, lockpread                        10758  # iopsynch_cvwait                10360  # pthread條件變量,等待read                         9963   # iofcntl                        8403   # iomprotect                     8247   # memorymmap                         8225   # memorygettimeofday                 7531   # 時(shí)間戳psynch_cvsignal              6862   # pthread條件變量，發(fā)送信號(hào)writev                       6048   # ioread_nocancel                4892   # iofstat64                      4817   # iopwrite                       3646   # iowrite_nocancel               3446   # ioclose                        2850   # iogetsockopt                   2818   # 網(wǎng)絡(luò)stat64                       2811   # iopselect                      2457   # io多路復(fù)用psynch_mutexwait             1923   # mutex, lockpsynch_mutexdrop             1918   # mutex, unlockpsynch_cvbroad               1826   # pthread條件變量，發(fā)送廣播信號(hào)
名稱                          次數(shù)
ulock_wake                   15346  # unfair lock, unlock
ulock_wait2                  15283  # unfair lock, lock
pread                        10758  # io
psynch_cvwait                10360  # pthread條件變量,等待
read                         9963   # io
fcntl                        8403   # io
mprotect                     8247   # memory
mmap                         8225   # memory
gettimeofday                 7531   # 時(shí)間戳
psynch_cvsignal              6862   # pthread條件變量，發(fā)送信號(hào)
writev                       6048   # io
read_nocancel                4892   # io
fstat64                      4817   # io
pwrite                       3646   # io
write_nocancel               3446   # io
close                        2850   # io
getsockopt                   2818   # 網(wǎng)絡(luò)
stat64                       2811   # io
pselect                      2457   # io多路復(fù)用
psynch_mutexwait             1923   # mutex, lock
psynch_mutexdrop             1918   # mutex, unlock
psynch_cvbroad               1826   # pthread條件變量，發(fā)送廣播信號(hào)

class CallstackTable{public:    struct Node    {        uint64_t parent;        uint64_t address;    };
        struct NodeHash {        size_t operator()(const Node* node) const {            size_t h = std::hash<uint64_t>{}(node->parent);            h ^= std::hash<uint64_t>{}(node->address);            return h;        }    };        struct NodeEqual    {        bool operator()(const Node* node1, const Node* node2) const noexcept        {            bool result = (node1->parent == node2->parent) && (node1->address == node2->address);            return result;        }    };    using CallStackSet = hash_set<Node *, NodeHash, NodeEqual>;private:    CallStackSet stack_set_;};

class CallstackTable
{
public:
    struct Node
    {
        uint64_t parent;
        uint64_t address;
    };


        struct NodeHash {
        size_t operator()(const Node* node) const {
            size_t h = std::hash<uint64_t>{}(node->parent);
            h ^= std::hash<uint64_t>{}(node->address);
            return h;
        }
    };
    
    struct NodeEqual
    {
        bool operator()(const Node* node1, const Node* node2) const noexcept
        {
            bool result = (node1->parent == node2->parent) && (node1->address == node2->address);
            return result;
        }
    };
    using CallStackSet = hash_set<Node *, NodeHash, NodeEqual>;
private:
    CallStackSet stack_set_;
};

bool active(uint64_t thread_id) {    mach_msg_type_number_t thread_info_count = THREAD_BASIC_INFO_COUNT;    kern_return_t res = thread_info(thread_id, THREAD_BASIC_INFO, reinterpret_cast<thread_info_t>(info), &thread_info_count);    if (unlikely((res != KERN_SUCCESS)))    {        return false;    }    return (info.run_state == TH_STATE_RUNNING && (info.flags & TH_FLAGS_IDLE) == 0);}

bool active(uint64_t thread_id) 
{
    mach_msg_type_number_t thread_info_count = THREAD_BASIC_INFO_COUNT;
    kern_return_t res = thread_info(thread_id, THREAD_BASIC_INFO, reinterpret_cast<thread_info_t>(info), &thread_info_count);
    if (unlikely((res != KERN_SUCCESS)))
    {
        return false;
    }
    return (info.run_state == TH_STATE_RUNNING && (info.flags & TH_FLAGS_IDLE) == 0);
}

The thread_suspend function increments the suspend count for target_thread and prevents the thread from executing any more user-level instructions.
In this context, a user-level instruction can be either a machine instruction executed in user mode or a system trap instruction, including a page fault. If a thread is currently executing within a system trap, the kernel code may continue to execute until it reaches the systemreturn code or it may suspend within the kernel code. In either case, the system trap returns when the thread resumes.

 
 
 The thread_suspend function increments the suspend count for target_thread and prevents the thread from executing any more user-level instructions.
In this context, a user-level instruction can be either a machine instruction executed in user mode or a system trap instruction, including a page fault. If a thread is currently executing within a system trap, the kernel code may continue to execute until it reaches the systemreturn code or it may suspend within the kernel code. In either case, the system trap returns when the thread resumes.
The thread_suspend function increments the suspend count for target_thread and prevents the thread from executing any more user-level instructions.


In this context, a user-level instruction can be either a machine instruction executed in user mode or a system trap instruction, including a page fault. If a thread is currently executing within a system trap, the kernel code may continue to execute until it reaches the systemreturn code or it may suspend within the kernel code. In either case, the system trap returns when the thread resumes.

// 生成一個(gè)虛擬的 Root 節(jié)點(diǎn)，待完成解析后，Root 的子樹(shù)便構(gòu)成了 Trace 的森林CallNode root = CallNode.makeRoot();Stack<CallNode> stack = new Stack<>();stack.push(root);...for (int i = 0; i < stackList.size(); i++) {    StackItem curStackItem = stackList.get(i);    nanoTime = curStackItem.nanoTime;    // 第一個(gè)堆棧全部入棧    if (i == 0) {        for (String name : curStackItem.stackTrace) {            stack.push(new CallNode(curStackItem.tid, name, nanoTime, stack.peek()));        }    } else {        // 當(dāng)前堆棧與前一個(gè)堆棧對(duì)比，自頂向下，找到第一個(gè)不同的函數(shù)        StackItem preStackItem = stackList.get(i - 1);        int preIndex = 0;        int curIndex = 0;        while (preIndex < preStackItem.size() && curIndex < curStackItem.size()) {            if (preStackItem.getPtr(preIndex) != curStackItem.getPtr(curIndex)) {                break;            }            preIndex++;            curIndex++;        }        // 前一個(gè)堆棧中不同的函數(shù)全部出棧        for (; preIndex < preStackItem.size(); preIndex++) {            stack.pop().end(nanoTime);        }        // 當(dāng)前堆棧中不同的函數(shù)全部入棧        for (; curIndex < curStackItem.size(); curIndex++) {            String name = curStackItem.get(curIndex);            stack.push(new CallNode(curStackItem.tid, name, nanoTime, stack.peek()));        }    }}// 遺留在棧中的函數(shù)全部出棧while (!stack.isEmpty()) {    stack.pop().end(nanoTime);}

// 生成一個(gè)虛擬的 Root 節(jié)點(diǎn)，待完成解析后，Root 的子樹(shù)便構(gòu)成了 Trace 的森林
CallNode root = CallNode.makeRoot();
Stack<CallNode> stack = new Stack<>();
stack.push(root);
...
for (int i = 0; i < stackList.size(); i++) {
    StackItem curStackItem = stackList.get(i);
    nanoTime = curStackItem.nanoTime;
    // 第一個(gè)堆棧全部入棧
    if (i == 0) {
        for (String name : curStackItem.stackTrace) {
            stack.push(new CallNode(curStackItem.tid, name, nanoTime, stack.peek()));
        }
    } else {
        // 當(dāng)前堆棧與前一個(gè)堆棧對(duì)比，自頂向下，找到第一個(gè)不同的函數(shù)
        StackItem preStackItem = stackList.get(i - 1);
        int preIndex = 0;
        int curIndex = 0;
        while (preIndex < preStackItem.size() && curIndex < curStackItem.size()) {
            if (preStackItem.getPtr(preIndex) != curStackItem.getPtr(curIndex)) {
                break;
            }
            preIndex++;
            curIndex++;
        }
        // 前一個(gè)堆棧中不同的函數(shù)全部出棧
        for (; preIndex < preStackItem.size(); preIndex++) {
            stack.pop().end(nanoTime);
        }
        // 當(dāng)前堆棧中不同的函數(shù)全部入棧
        for (; curIndex < curStackItem.size(); curIndex++) {
            String name = curStackItem.get(curIndex);
            stack.push(new CallNode(curStackItem.tid, name, nanoTime, stack.peek()));
        }
    }
}
// 遺留在棧中的函數(shù)全部出棧
while (!stack.isEmpty()) {
    stack.pop().end(nanoTime);
}

static uint64_t thread_cpu_time_nanos() {    struct timespec t;    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &t);    return t.tv_sec * 1000000000LL + t.tv_nsec;}
static uint64_t thread_cpu_time_nanos() {
    struct timespec t;
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &t);
    return t.tv_sec * 1000000000LL + t.tv_nsec;
}

thread_local rheatrace::JavaObjectStat::ObjectStat stats;
void rheatrace::JavaObjectStat::onObjectAllocated(size_t b) {    stats.objects++;    stats.bytes += b;}
thread_local rheatrace::JavaObjectStat::ObjectStat stats;


void rheatrace::JavaObjectStat::onObjectAllocated(size_t b) {
    stats.objects++;
    stats.bytes += b;
}

struct rusage ru;if (getrusage(RUSAGE_THREAD, &ru) == 0) {    r.mMajFlt = ru.ru_majflt;    r.mNvCsw = ru.ru_nvcsw;    r.mNivCsw = ru.ru_nivcsw;}
struct rusage ru;
if (getrusage(RUSAGE_THREAD, &ru) == 0) {
    r.mMajFlt = ru.ru_majflt;
    r.mNvCsw = ru.ru_nvcsw;
    r.mNivCsw = ru.ru_nivcsw;
}

static void *currentMainMonitor = nullptr;static uint64_t currentMainNano = 0;
void *Monitor_MonitorEnter(void *self, void *obj, bool trylock) {SHADOWHOOK_STACK_SCOPE();    if (rheatrace::isMainThread()) {        rheatrace::ScopeSampling a(rheatrace::SamplingType::kMonitor, self);        currentMainMonitor = obj; // 記錄當(dāng)前阻塞的鎖        currentMainNano = a.beginNano_;        void *result = SHADOWHOOK_CALL_PREV(Monitor_MonitorEnter, self, obj, trylock);        currentMainMonitor = nullptr; // 鎖已經(jīng)拿到，這里重置        return result;    }    ...}
bool Monitor_MonitorExit(void *self, void *obj) {SHADOWHOOK_STACK_SCOPE();    if (!rheatrace::isMainThread()) {        if (currentMainMonitor == obj) { // 當(dāng)前釋放的鎖正式主線程等待的鎖           rheatrace::SamplingCollector::request(rheatrace::SamplingType::kUnlock, self, true, true, currentMainNano); // 強(qiáng)制抓棧，并通過(guò) currentMainNano 和主線程建立聯(lián)系A(chǔ)LOGX("Monitor_MonitorExit wakeup main lock %ld", currentMainNano);        }    }    return SHADOWHOOK_CALL_PREV(Monitor_MonitorExit, self, obj);}

static void *currentMainMonitor = nullptr;
static uint64_t currentMainNano = 0;


void *Monitor_MonitorEnter(void *self, void *obj, bool trylock) {
SHADOWHOOK_STACK_SCOPE();
    if (rheatrace::isMainThread()) {
        rheatrace::ScopeSampling a(rheatrace::SamplingType::kMonitor, self);
        currentMainMonitor = obj; // 記錄當(dāng)前阻塞的鎖
        currentMainNano = a.beginNano_;
        void *result = SHADOWHOOK_CALL_PREV(Monitor_MonitorEnter, self, obj, trylock);
        currentMainMonitor = nullptr; // 鎖已經(jīng)拿到，這里重置
        return result;
    }
    ...
}


bool Monitor_MonitorExit(void *self, void *obj) {
SHADOWHOOK_STACK_SCOPE();
    if (!rheatrace::isMainThread()) {
        if (currentMainMonitor == obj) { // 當(dāng)前釋放的鎖正式主線程等待的鎖
           rheatrace::SamplingCollector::request(rheatrace::SamplingType::kUnlock, self, true, true, currentMainNano); // 強(qiáng)制抓棧，并通過(guò) currentMainNano 和主線程建立聯(lián)系
ALOGX("Monitor_MonitorExit wakeup main lock %ld", currentMainNano);
        }
    }
    return SHADOWHOOK_CALL_PREV(Monitor_MonitorExit, self, obj);
}