卡顿监控

最近参考Matrix做了卡顿监控的流程，整体流程思想就不多说了。这里注释了核心方法代码，做下记录，也方便大家阅读代码。

1. 子线程监听-核心主流程

while (YES) {
        @autoreleasepool {
            if (g_bMonitor) {
                SDumpType dumpType = [self check];
                if (m_bStop) {
                    break;
                }
                
                if (dumpType != SDumpType_Unlag) {
                    // 主线程卡顿
                    if (SDumpType_BackgroundMainThreadBlock == dumpType || SDumpType_MainThreadBlock == dumpType) {
                        // 线程数超出64个时会导致主线程卡顿，如果卡顿是由于线程多造成的，那么就没必 要通过获取主线程堆栈去找卡顿原因了(线程过多时 CPU 在切换线程上下文时，还会更新寄存器，更新寄存器时需要寻址，而寻址的过程还会有较大的 CPU 消耗) 否则，不是因为线程过多造成的卡顿，则更新最近最耗时的堆栈，并回到主线程写入文件记录
                        if (g_CurrentThreadCount > 64) {
                            dumpType = SDumpType_BlockThreadTooMuch;
                            [self dumpWithType:dumpType];
                        } else {
                            // 需要过滤
                            SFilterType filterType = [self needFilter];
                            if (filterType == SFilterType_None) {
                                if (g_MainThreadHandle) {
                                    if (g_PointMainThreadArray != NULL) {
                                        free(g_PointMainThreadArray);
                                        g_PointMainThreadArray = NULL;
                                        g_PointStackCount = 0;
                                    }
                                    g_PointMainThreadArray = [m_pointMainThreadHandler getPointStack:g_PointStackCount];
                                    g_PointMainThreadRepeatCountArray = [m_pointMainThreadHandler getPointStackRepeatCount];
                                    [self dumpWithType:dumpType];
                                    
                                    if (g_PointMainThreadArray != NULL) {
                                        free(g_PointMainThreadArray);
                                        g_PointMainThreadArray = NULL;
                                        g_PointStackCount = 0;
                                    }
                                } else {
                                    [self dumpWithType:dumpType];
                                }
                            } else {
                               
                            }
                        }
                    } else {
                        [self dumpWithType:dumpType];
                    }
                } else {
                    // 没有卡顿，重置状态
                    [self resetStatus];
                }
            }

            // 随着时间间隔变长， 每次主线程堆栈存储的次数就变多
            // 代表当前堆栈卡顿时间很长
            for (int nCnt = 0; nCnt < m_nIntervalTime && !m_bStop; nCnt++) {
                if (g_MainThreadHandle && g_bMonitor) {
                    // 1s / 50ms
                    int intervalCount = g_CheckPeriodTime / g_PerStackInterval;
                    if (intervalCount <= 0) {
                        // 休眠 1s
                        usleep(g_CheckPeriodTime);
                    } else {
                        for (int index = 0; index < intervalCount && !m_bStop; index++) {
                            // 休眠 50ms
                            // 每50ms去获取主线程堆栈
                            usleep(g_PerStackInterval);
                            size_t stackBytes = sizeof(uintptr_t) * g_StackMaxCount;
                            uintptr_t *stackArray = (uintptr_t *)malloc(stackBytes);
                            if (stackArray == NULL) {
                                continue;
                            }
                            __block size_t nSum = 0;
                            memset(stackArray, 0, stackBytes);
                            // 暂停主线程， 获取线程堆栈
                            [SMachHelper getCurrentMainThreadStack:^(NSUInteger pc) {
                                stackArray[nSum] = (uintptr_t)pc;
                                nSum++;
                            } withMaxEntries:g_StackMaxCount];
                            // 最多存储10组堆栈， 每组堆栈最多50行
                            [m_pointMainThreadHandler addThreadStack:stackArray andStackCount:nSum];
                        }
                    }
                } else {
                    // 休眠 1s
                    usleep(g_CheckPeriodTime);
                 }
            }

            if (m_bStop) {
                break;
            }
        }
    }

2. 检查是否是卡顿

- (SDumpType)check {

    BOOL tmp_g_bRun = g_bRun;
    
    // runloop运行的最后时间
    struct timeval tmp_g_tvRun = g_tvRun;

    // 当前时间
    struct timeval tvCur;
    gettimeofday(&tvCur, NULL);
    
    // 计算时间间隔， 但是微秒
    unsigned long long diff = [SANRMonitor diffTime:&tmp_g_tvRun endTime:&tvCur];

    // TODO: 目前g_tvSuspend就是启动时间，永远比tmp_g_tvRun小
    struct timeval tmp_g_tvSuspend = g_tvSuspend;
    if (__timercmp(&tmp_g_tvSuspend, &tmp_g_tvRun, >)) {
        return SDumpType_Unlag;
    }

    m_blockDiffTime = 0;
    
    // 运行中 & 运行时间非空 & 运行时间<当前时间 & 时间间隔>200ms
    if (tmp_g_bRun && tmp_g_tvRun.tv_sec && tmp_g_tvRun.tv_usec && __timercmp(&tmp_g_tvRun, &tvCur, <) && diff > g_RunLoopTimeOut) {
        m_blockDiffTime = diff;

        // TODO: 一直在前端， 这个不会走
        if (g_bBackgroundLaunch) {
            return SDumpType_Unlag;
        }

        if (m_currentState == UIApplicationStateBackground) {
            if (g_enterBackground.tv_sec != 0 || g_enterBackground.tv_usec != 0) {
                // 计算在后台了多少时间=当前时间-进入后台时间
                unsigned long long enterBackgroundTime = [SANRMonitor diffTime:&g_enterBackground endTime:&tvCur];
                // TODO: 进入后台的时间<当前时间 & 在后台了的时间>180s
                if (__timercmp(&g_enterBackground, &tvCur, <) && (enterBackgroundTime > APP_SHOULD_SUSPEND)) {
                    return SDumpType_Unlag;
                }
            }

            return SDumpType_BackgroundMainThreadBlock;
        }
        return SDumpType_MainThreadBlock;
    }

    return SDumpType_Unlag;
}

3. 过滤堆栈信息，判断是否有重复堆栈信息等... 避免重复记录

- (SFilterType)needFilter {
    BOOL bIsSame = NO;
    static std::vector<NSUInteger> vecCallStack(300);
    __block NSUInteger nSum = 0;
    __block NSUInteger stackFeat = 0; // use the top stack address;

    // TODO: g_MainThreadHandle一直是YES
    if (g_MainThreadHandle) {
        nSum = [m_pointMainThreadHandler getLastMainThreadStackCount];
        uintptr_t *stack = [m_pointMainThreadHandler getLastMainThreadStack];
        if (stack) {
            for (size_t i = 0; i < nSum; i++) {
                vecCallStack[i] = stack[i];
            }
            // 获取最后堆栈的栈顶 符号地址
            stackFeat = kssymbolicate_symboladdress(stack[0]);
        } else {
            nSum = 0;
        }
    }

    // 堆栈层级太少 直接返回
    if (nSum <= 1) {
        return SFilterType_Meaningless;
    }
    
    // 判断堆栈是否和之前一样
    if (nSum == m_lastMainThreadStackCount) {
        NSUInteger index = 0;
        for (index = 0; index < nSum; index++) {
            if (vecCallStack[index] != m_vecLastMainThreadCallStack[index]) {
                break;
            }
        }
        if (index == nSum) {
            bIsSame = YES;
        }
    }

    if (bIsSame) {
        // 如果堆栈记录与之前一样  则使用退火算法，修改检测时间间隔，每次增加1s
        NSUInteger lastTimeInterval = m_nIntervalTime;
        m_nIntervalTime = m_nLastTimeInterval + m_nIntervalTime;
        m_nLastTimeInterval = lastTimeInterval;
        return SFilterType_Annealing;
    } else {
        m_nIntervalTime = 1;
        m_nLastTimeInterval = 1;

        // 如果不一样 更新记录的最后一次调用栈
        //update last call stack
        m_vecLastMainThreadCallStack.clear();
        m_lastMainThreadStackCount = 0;
        for (NSUInteger index = 0; index < nSum; index++) {
            m_vecLastMainThreadCallStack.push_back(vecCallStack[index]);
            m_lastMainThreadStackCount++;
        }

        // 过滤重复的堆栈信息
        // 如果栈顶符号存储过超过3次，那么认为重复记录
        if (g_filterSameStack) {
            NSUInteger repeatCnt = [m_stackHandler addStackFeat:stackFeat];
            if (repeatCnt > g_triggerdFilterSameCnt) {
                return SFilterType_TrigerByTooMuch;
            }
        }
        return SFilterType_None;
    }
}

4. 找到重复最多的堆栈

- (uintptr_t *)getPointStack:(size_t &)count {
    pthread_mutex_lock(&m_threadLock);
    size_t maxValue = 0;
    BOOL trueStack = NO;
    for (int i = 0; i < m_cycleArrayCount; i++) {
        size_t currentValue = m_topStackAddressRepeatArray[i];
        int stackCount = (int)m_mainThreadStackCount[i];
        // 找到10层以上 同时 次数最多的
        if (currentValue >= maxValue && stackCount > SHORTEST_LENGTH_OF_STACK) {
            maxValue = currentValue;
            trueStack = YES;
        }
    }

    if (!trueStack) {
        pthread_mutex_unlock(&m_threadLock);
        return NULL;
    }

    // 找到对应堆栈索引
    size_t currentIndex = (m_tailPoint + m_cycleArrayCount - 1) % m_cycleArrayCount;
    for (int i = 0; i < m_cycleArrayCount; i++) {
        int trueIndex = (m_tailPoint + m_cycleArrayCount - i - 1) % m_cycleArrayCount;
        int stackCount = (int)m_mainThreadStackCount[trueIndex];
        if (m_topStackAddressRepeatArray[trueIndex] == maxValue && stackCount > SHORTEST_LENGTH_OF_STACK) {
            currentIndex = trueIndex;
            break;
        }
    }

    // current count of point stack
    size_t stackCount = m_mainThreadStackCount[currentIndex];
    size_t pointThreadSize = sizeof(uintptr_t) * stackCount;
    uintptr_t *pointThreadStack = (uintptr_t *)malloc(pointThreadSize);

    size_t repeatCountArrayBytes = stackCount * sizeof(int);
    m_mainThreadStackRepeatCountArray = (int *)malloc(repeatCountArrayBytes);
    if (m_mainThreadStackRepeatCountArray != NULL) {
        memset(m_mainThreadStackRepeatCountArray, 0, repeatCountArrayBytes);
    }

    // calculate the repeat count
    for (size_t i = 0; i < stackCount; i++) {
        for (int innerIndex = 0; innerIndex < m_cycleArrayCount; innerIndex++) {
            size_t innerStackCount = m_mainThreadStackCount[innerIndex];
            for (size_t idx = 0; idx < innerStackCount; idx++) {
                // point stack i_th address compare to others
                if (m_mainThreadStackCycleArray[currentIndex][i] == m_mainThreadStackCycleArray[innerIndex][idx]) {
                    m_mainThreadStackRepeatCountArray[i] += 1;
                }
            }
        }
    }

    if (pointThreadStack != NULL) {
        memset(pointThreadStack, 0, pointThreadSize);
        for (size_t idx = 0; idx < stackCount; idx++) {
            pointThreadStack[idx] = m_mainThreadStackCycleArray[currentIndex][idx];
        }
        pthread_mutex_unlock(&m_threadLock);
        count = stackCount;
        return pointThreadStack;
    }
    pthread_mutex_unlock(&m_threadLock);
    return NULL;
}