EST. 2026 — บันทึกงานเซิร์ฟเวอร์จริง SYSADMIN · SECURITY · AI · DIRECTADMIN เล่มที่ 01
THE SYSADMIN ALMANAC
หน้าหลัก / Linux / หน้าจอค้างแต่ log ไม่บอกอะไร ทำ watchdog แยก busy blocked starved
Linux

หน้าจอค้างแต่ log ไม่บอกอะไร ทำ watchdog แยก busy blocked starved

โดย Ton-Or ·20 พ.ย. 2026·อ่าน 12 นาที
หน้าจอค้างแต่ log ไม่บอกอะไร ทำ watchdog แยก busy blocked starved

log ที่เงียบไม่ได้บอกว่าไม่มีอะไรเกิดขึ้น มันบอกแค่ว่า thread ที่มีหน้าที่เขียน log ไม่ได้เขียน ถ้าอยากรู้ว่าทำไม ต้องมีอีก thread หนึ่งที่ไม่ค้างไปด้วยกัน คอยจดให้ว่าตัวที่ค้างกำลังทำอะไรอยู่

สรุปใน 1 นาที

อาการ/ปัญหา
แอป C# ค้างราว 2 นาที ขณะที่หลังบ้านยังทำงาน และ log เงียบจนพิสูจน์สาเหตุย้อนหลังไม่ได้
ใครควรอ่าน
คนทำแอปเดสก์ท็อปที่หน้าจอค้างเป็นพัก ๆ โดยไม่มีร่องรอยใน log
ทางแก้แบบสั้น
ทำ watchdog thread ส่งข้อความเลขลำดับเข้าคิว UI ทุก 250 ms แล้วแยกว่า UI thread กำลัง BUSY, BLOCKED หรือ STARVED พร้อม dump หนึ่งครั้ง
ข้ามไปขั้นตอน

พอดีโปรแกรมหน้าจอมอนิเตอร์ข้อมูลเวลาจริงที่ผมเขียนด้วย C# ค้างไปราว 2 นาทีแล้ว process ก็หายไป ขณะที่เอนจินซึ่งเป็น process ลูกของมันทำงานปกติทุกอย่าง ผมเปิด log ของหน้าจอเพื่อดูว่าเกิดอะไรขึ้น แล้วพบว่ามันไม่บอกอะไรเลย บรรทัดสุดท้ายเป็นบรรทัด stats ธรรมดา แล้วก็เงียบ ผมเดาผิดไปสามเรื่องก่อนจะยอมรับว่าสาเหตุของครั้งนี้พิสูจน์ไม่ได้จากข้อมูลที่มี สิ่งที่ทำได้คือสร้างเครื่องมือให้ครั้งหน้าพิสูจน์ได้

ในบทความนี้ผมเรียกโปรแกรมฝั่ง UI ว่าหน้าจอควบคุม และเรียก process หลังบ้านว่าเอนจิน ชื่อจริง path และรายละเอียดของข้อมูลผมตัดออกหมด ตัวเลขเวลา จำนวน thread และลำดับเหตุการณ์เป็นของจริง

สิ่งที่ log บอก และสิ่งที่มันไม่บอก

ข้อเท็จจริงทั้งหมดที่ได้จาก log ของหน้าจอมีเท่านี้ ผมเขียนย่อให้เหลือแต่โครง เวลาเป็นเวลานับจากบรรทัด stats สุดท้าย

t+0 s     stats: frames +105 ใน 10 วินาที          # บรรทัดปกติบรรทัดสุดท้ายจาก UI thread
          (เงียบ)
t+50 s    thread เบื้องหลัง: poll สถานะ timeout     # ประมาณ 50 วินาทีต่อมา
          thread เบื้องหลัง: poll สถานะกลับมาตอบ
          (เงียบ)
          ไม่มีบรรทัด exit 0                       # process หายไปภายในสองนาที

ฝั่งเอนจินไม่มีอะไรผิดปกติเลย เวลา round trip ของมันอยู่ในช่วงปกติของทั้งวัน คือ 10-268 ms ข้อนี้ไม่ใช่โชค แต่เป็นผลของการออกแบบ หน้าจอแค่อ่าน shared memory กับเขียนลงช่องคำสั่ง ไม่มีเส้นทางไหนที่เอนจินต้องรอหน้าจอ หน้าจอตายเลยไม่มีทางดันปัญหากลับไปหาเอนจินได้

สิ่งที่ log ไม่บอกคือคำถามเดียวที่ผมอยากรู้ ระหว่างที่เงียบอยู่นั้น UI thread กำลังทำอะไร มันวนลูปอยู่ มันรออะไรบางอย่างอยู่ หรือมันพร้อมจะทำงานแต่ไม่ได้ CPU สามคำตอบนี้พาไปแก้คนละที่กันเลย และ log ที่มีแยกสามอย่างนี้ออกจากกันไม่ได้

เดาผิดสามเรื่องที่ต้องจดไว้

เดาแรก บั๊กในทางวาด ก่อนค้างไม่นาน รายการบนจอเปลี่ยนจาก 1 แถวเป็น 0 แถว ผมเลยสงสัยว่าทางวาดตอนรายการว่างมีอะไรผิด ไล่โค้ดแล้วไม่ใช่ และมีหลักฐานแย้งชัดเจน ลำดับเดียวกันนี้เกิดขึ้นก่อนหน้านั้น 5 นาทีบน build เดียวกัน แล้วหน้าจอก็วาดต่อได้ตามปกติ

เดาที่สอง ลูปไม่จบ ระหว่างไล่โค้ด ผมเจอลูปไม่จบแฝงอยู่จริงหนึ่งจุด เป็นฟังก์ชันประมาณความสูงของข้อความที่จะวนไม่เลิกถ้าความกว้างที่ส่งเข้ามาน้อยกว่าหรือเท่ากับศูนย์ มันอธิบายอาการค้างได้พอดีจนน่าจะปิดเรื่องได้ แต่พอตามดูว่าใครเรียกฟังก์ชันนี้ ทาง production ไม่ได้ใช้ทางนั้นเลย มันเป็นบั๊กจริงที่ควรแก้ แต่ไม่ใช่สาเหตุของครั้งนี้

เดาที่สาม ช่องว่างของบรรทัด frames คือหลักฐานว่าค้าง ข้อนี้ผิดที่วิธีอ่าน log บรรทัด stats ของผมออกเฉพาะเมื่อมีเฟรมถูก present หน้าต่างที่ถูกย่อไม่ present เฟรมเลย พอย้อนไปดู log ของวันอื่นก็เจอช่องว่าง 760 วินาที และ 5,080 วินาที ในวันที่ไม่มีปัญหาอะไรเลย บรรทัดที่หายไปเลยไม่ได้แปลว่าค้าง มันแปลได้แค่ว่าไม่มีเฟรม

เจอบั๊กจริง ไม่ได้แปลว่าเจอสาเหตุ

ลูปไม่จบที่เจอระหว่างทางเป็นบั๊กของแท้ และมันอธิบายอาการค้างได้สวยงาม ถ้าผมหยุดตรงนั้น ผมจะแก้มัน ประกาศว่าเสร็จ แล้วรอให้อาการเดิมกลับมาใหม่ คำถามที่ต้องถามทุกครั้งคือ ทางที่มีบั๊กนั้นถูกเรียกจริงในเหตุการณ์นี้ไหม ถ้าตอบไม่ได้ว่าใช่ ก็ยังไม่ใช่สาเหตุ

ผู้ต้องสงสัยอันดับหนึ่ง ที่พิสูจน์ไม่ได้

สิ่งเดียวที่เกิดขึ้นพร้อมกันและอธิบายอาการได้ คือเครื่องเดียวกันนั้นกำลัง build เอนจินแบบ release อยู่ build เริ่มก่อนหน้าราว 2 นาที มี compiler 14 process ใช้ 16 thread เต็ม 100% ต่อเนื่อง แล้วตามด้วย build ของชุดเทสต์อีกรอบ

ราว 2 นาทีช่วงที่หน้าจอค้างก่อน process หาย
+105เฟรมใน 10 วินาทีสุดท้ายก่อนเงียบ
14process ของ compiler ที่รันพร้อมกัน
16 threadถูกใช้เต็ม 100% ต่อเนื่อง
10-268 msround trip ของเอนจิน ปกติทั้งวัน
5,080 วินาทีช่องว่าง frames ในวันที่ไม่มีปัญหา

สรุปตรง ๆ คือสาเหตุพิสูจน์ไม่ได้จาก log ที่มี อันดับหนึ่งคือ CPU starvation แต่มันเป็นแค่อันดับหนึ่ง ไม่ใช่ข้อสรุป ผมไม่มีข้อมูลว่า UI thread ได้ CPU ไปเท่าไรในช่วงนั้น และไม่มี stack ของมัน การเขียนลงบันทึกว่า "สาเหตุคือ build แย่ง CPU" จะเป็นการเอาความน่าจะเป็นไปปลอมเป็นข้อเท็จจริง งานที่เหลือเลยแบ่งเป็นสองส่วน ทำให้ครั้งหน้าพิสูจน์ได้ และลดโอกาสของผู้ต้องสงสัยอันดับหนึ่งไปพร้อมกัน

watchdog ในโปรเซส: ข้อความเลขลำดับทุก 250 ms

ตัวเฝ้าจากข้างนอกแบบที่ผมเคยเขียนถึงใน บทความเรื่อง watchdog ที่นับตัวเอง ตอบได้แค่ว่า process ยังอยู่ไหม ซึ่งในเหตุการณ์นี้คำตอบคือยังอยู่ตลอดช่วงที่ค้าง สิ่งที่ผมต้องการคือตัวเฝ้าที่อยู่ข้างใน process เดียวกัน เห็น thread เดียวกัน และตอบได้ว่าค้างแบบไหน

กลไกมีแค่นี้ครับ thread ตัวหนึ่งที่ไม่ใช่ UI thread ส่งข้อความที่มีเลขลำดับเข้าคิวของหน้าต่างด้วย PostMessage ทุก 250 ms UI thread รับแล้วบันทึกเลขล่าสุดที่รับไว้ ถ้า UI thread ยังหมุน message loop อยู่ ข้อความจะถูกรับภายในไม่กี่มิลลิวินาที ถ้าข้อความใดไม่ถูกรับภายใน 3 วินาที ถือว่าค้าง

watchdogUI threadส่งทุก 250 msข้อความมีเลขลำดับ #nackackackackไม่มี ack 3 วินาทีUI STALL: เขียนรายงาน + ตัดสินBUSYCPU ของ UI threadมากกว่า 60% ของช่วงค้างBLOCKEDThreadState = Waitพร้อม WaitReasonSTARVEDพร้อมรัน แต่ไม่ได้ CPUดู CPU รวม + 6 processค้างเกิน 10 วินาที: createdump หนึ่งครั้งต่อการรัน รายงานซ้ำทุก 30 วินาที
ข้อความที่ไม่ถูกรับใน 3 วินาทีคือสัญญาณเดียวที่ใช้ตัดสินว่าค้าง จากนั้น watchdog วัดสองอย่างของ UI thread คือเวลา CPU ที่ใช้ไประหว่างค้าง กับสถานะของ thread แล้วจัดเข้าหนึ่งในสามกลุ่ม

ผมแยกตรรกะนับเวลาออกมาเป็นคลาสที่ไม่มีนาฬิกาของตัวเอง รับเวลาปัจจุบันเข้ามาเป็นตัวเลข เหตุผลคือจะได้เทสต์ได้โดยไม่ต้องรอเวลาจริงสักมิลลิวินาที

public sealed class HangMonitor
{
    public long StallMs = 3000, DumpMs = 10_000, RepostMs = 2000, RepeatMs = 30_000;
    private long _sent, _acked, _sentAt, _postedAt, _reportedAt = -1, _stallFrom;
    private bool _dumped;

    public readonly struct Step
    {
        public bool Post { get; init; }        // ให้โพสต์ข้อความเลข Seq เข้าหน้าต่างตอนนี้
        public long Seq { get; init; }
        public bool Report { get; init; }      // ให้เขียนรายงาน UI STALL
        public bool Dump { get; init; }        // ให้สั่ง dump (ครั้งเดียวต่อการรัน)
        public long EndedMs { get; init; }     // การค้างเพิ่งจบ: ยาวกี่ ms (0 = ไม่มี)
        public long StalledMs { get; init; }
    }

    // UI thread เรียกเมื่อรับข้อความเลข seq แล้ว
    public void Ack(long seq)
    {
        long a;
        do { a = Interlocked.Read(ref _acked); }
        while (seq > a && Interlocked.CompareExchange(ref _acked, seq, a) != a);
    }

    // watchdog thread เรียกทุก 250 ms
    public Step Check(long now)
    {
        if (Interlocked.Read(ref _acked) >= _sent)
        {
            long ended = _reportedAt >= 0 ? Math.Max(1, now - _stallFrom) : 0;
            _reportedAt = -1;
            _sent++;
            _sentAt = _postedAt = now;
            return new Step { Post = true, Seq = _sent, EndedMs = ended };
        }
        long stalled = now - _sentAt;
        bool repost = now - _postedAt >= RepostMs;       // เผื่อข้อความที่โพสต์ไปหาย
        if (repost) _postedAt = now;
        bool report = false, dump = false;
        if (stalled >= StallMs && (_reportedAt < 0 || now - _reportedAt >= RepeatMs))
        {
            if (_reportedAt < 0) _stallFrom = _sentAt;
            _reportedAt = now;
            report = true;
        }
        if (stalled >= DumpMs && !_dumped) { _dumped = true; dump = true; }
        return new Step { Post = repost, Seq = _sent, Report = report, Dump = dump, StalledMs = stalled };
    }
}

ฝั่ง UI thread มีงานเพิ่มแค่สองบรรทัดใน window procedure จดว่ากำลังจัดการข้อความอะไรอยู่ และตอบรับข้อความของ watchdog

private const uint WM_APP = 0x8000;
private const uint WM_WATCHDOG = WM_APP + 41;

private IntPtr WndProc(IntPtr hwnd, uint msg, IntPtr wParam, IntPtr lParam)
{
    _watchdog.Seen(msg);                               // เขียนตัวแปรสองตัว ถูกพอจะเรียกทุกข้อความ
    if (msg == WM_WATCHDOG)
    {
        _watchdog.Ack(wParam.ToInt64());               // เลขลำดับมากับ wParam
        return IntPtr.Zero;
    }
    return HandleMessage(hwnd, msg, wParam, lParam);   // ข้อความอื่นของหน้าต่างตามปกติ
}

จุดที่ต้องระวังคือ thread ของ watchdog ตั้ง priority ไว้ที่ above normal เพราะถ้าเครื่องโหลดเต็มจนตัวเฝ้าเองก็ไม่ได้รัน ก็ไม่เหลือใครจดอะไรทั้งนั้น และระหว่างที่ค้าง มันไม่โพสต์ข้อความใหม่ทุก 250 ms มันโพสต์ซ้ำเลขเดิมทุก 2 วินาทีเท่านั้น คิวของหน้าต่างเลยไม่ถูกถมด้วยข้อความของตัวเฝ้า

แยกสามแบบ: BUSY, BLOCKED, STARVED

พอรู้ว่าค้าง สิ่งที่ต้องตอบต่อคือค้างแบบไหน ผมใช้ตัววัดสองตัวที่อ่านได้จากข้างนอก UI thread โดยไม่ต้องให้มันร่วมมือ ตัวแรกคือเวลา CPU ที่ UI thread ใช้ไประหว่างค้าง อ่านด้วย GetThreadTimes บน handle ที่เปิดไว้ครั้งเดียวตอนสตาร์ต ตัวที่สองคือสถานะของ thread จาก Process.Threads

// _uiThread = OpenThread(THREAD_QUERY_LIMITED_INFORMATION, false, uiThreadId) เปิดครั้งเดียวตอนสตาร์ต
// _uiCpuAtPost = เวลา CPU ของ UI thread ตอนโพสต์ข้อความที่ยังไม่ถูกรับ
private string Verdict(long stalledMs)
{
    string state = "?";
    using (Process me = Process.GetCurrentProcess())
        foreach (ProcessThread t in me.Threads)
            if (t.Id == _uiTid)
                state = t.ThreadState == System.Diagnostics.ThreadState.Wait
                    ? "Wait/" + t.WaitReason                 // WaitReason อ่านได้เฉพาะตอนสถานะเป็น Wait
                    : t.ThreadState.ToString();

    if (!GetThreadTimes(_uiThread, out _, out _, out long kernel, out long user))
        return "UNKNOWN, state " + state;
    double usedMs = (TimeSpan.FromTicks(kernel + user) - _uiCpuAtPost).TotalMilliseconds;

    if (usedMs > 0.6 * stalledMs) return $"BUSY, cpu {usedMs:0} ms, state {state}";
    if (state.StartsWith("Wait", StringComparison.Ordinal)) return $"BLOCKED, state {state}";
    return $"STARVED, cpu {usedMs:0} ms, state {state}";
}

[DllImport("kernel32.dll")]
private static extern bool GetThreadTimes(IntPtr h, out long create, out long exit, out long kernel, out long user);
คำตัดสิน เงื่อนไข แปลว่า ไปดูที่ไหนต่อ
BUSY เวลา CPU ของ UI thread เกิน 60% ของช่วงที่ค้าง มีลูปหรืองานหนักรันอยู่บน UI thread stack ใน dump, เฟสล่าสุดในรายงาน
BLOCKED สถานะ thread เป็น Wait รอ lock, I/O หรือ thread อื่น WaitReason, สถานะของ thread อื่นในแอป
STARVED ที่เหลือ: ใช้ CPU น้อย และไม่ได้อยู่ในสถานะ Wait พร้อมรันแต่ไม่ได้ CPU CPU รวมของเครื่อง, 6 process ที่กินมากสุด

รายงานหนึ่งบรรทัดเลยเก็บมากกว่าคำตัดสิน มันมีข้อความหน้าต่างล่าสุดที่ UI thread กำลังจัดการ เฟสล่าสุด (frame build, frame render หรือ wake refresh) เวลา CPU ของ UI thread ระหว่างค้าง CPU รวมของเครื่อง 6 process ที่กิน CPU มากที่สุด และสถานะของทุก thread ในแอป

# รูปแบบของบรรทัดรายงาน (ค่าในวงเล็บแหลมคือค่าที่วัดได้ตอนนั้น)
UI STALL <n> s: the UI thread (tid <id>) has not taken the watchdog message;
  last window message <msg> <n> s ago; phase '<frame build|frame render|wake refresh>' since <n> s;
  UI thread state <state>, cpu <n> ms during the stall -> <BUSY|BLOCKED|STARVED>;
  system cpu <n>% of 16 threads; top processes <name xN pct>, ...; threads <id state cpu>, ...
UI STALL ended after <n> s
คำตัดสินคือสมมุติฐาน หลักฐานคือตัวเลขข้างหลัง

สถานะ thread ที่อ่านได้เป็นภาพ ณ วินาทีเดียว และกลุ่ม STARVED ถูกนิยามด้วยการคัดออก คือไม่ใช่ BUSY และไม่ใช่ Wait มันเลยเป็นกลุ่มที่มั่นใจได้น้อยที่สุดในสามกลุ่ม ผมให้รายงานพิมพ์ตัวเลขดิบไว้ครบทุกตัวด้วยเหตุนี้ ถ้าคำตัดสินบอก STARVED แล้ว CPU รวมของเครื่องอยู่ที่ 100% พร้อมรายชื่อ process ที่กินอยู่ ก็เชื่อได้ ถ้าบอก STARVED แต่เครื่องว่าง แปลว่าต้องเปิด dump ดูเอง

dump หนึ่งครั้ง และชีพจรที่ไม่ขึ้นกับเฟรม

รายงานบรรทัดเดียวบอกได้ว่าค้างแบบไหน แต่ถ้าเป็น BUSY หรือ BLOCKED สิ่งที่อยากได้จริง ๆ คือ stack หลังค้างเกิน 10 วินาที watchdog เลยสั่ง createdump ซึ่งเป็นตัวที่มากับ runtime ของ .NET อยู่แล้ว ให้ dump process ของตัวเองแบบมี heap หนึ่งครั้งต่อการรัน และเก็บไว้แค่ 3 ไฟล์ล่าสุด เพราะ dump แบบมี heap ไฟล์ใหญ่ ถ้าปล่อยให้ dump ทุกครั้งที่ค้าง ดิสก์จะเต็มก่อนจะมีใครมาเปิดอ่าน

private void Dump()
{
    string exe = Path.Combine(RuntimeEnvironment.GetRuntimeDirectory(), "createdump.exe");
    if (!File.Exists(exe)) { _log.Warn("UI STALL dump: ไม่พบ createdump ข้าง runtime"); return; }

    Directory.CreateDirectory(_dumpDir);
    FileInfo[] olds = new DirectoryInfo(_dumpDir).GetFiles("ui-*.dmp");
    Array.Sort(olds, (a, b) => b.LastWriteTimeUtc.CompareTo(a.LastWriteTimeUtc));
    for (int i = 2; i < olds.Length; i++)                      // เหลือ 2 ไฟล์เก่า + ไฟล์ใหม่ = 3
        try { olds[i].Delete(); } catch (IOException) { }

    string file = Path.Combine(_dumpDir, $"ui-{Environment.ProcessId}-{DateTime.UtcNow:yyyyMMdd-HHmmss}.dmp");
    var si = new ProcessStartInfo(exe) { UseShellExecute = false, CreateNoWindow = true };
    si.ArgumentList.Add(Environment.ProcessId.ToString(CultureInfo.InvariantCulture));
    si.ArgumentList.Add("-f");
    si.ArgumentList.Add(file);
    si.ArgumentList.Add("--withheap");
    using Process? p = Process.Start(si);
    bool done = p != null && p.WaitForExit(60_000);
    _log.Warn(done && File.Exists(file) ? "UI STALL dump written: " + file : "UI STALL dump failed: " + file);
}

เปิดอ่านด้วยเครื่องมือมาตรฐานของ .NET ได้เลย

dotnet tool install -g dotnet-dump
dotnet-dump analyze ui-<pid>-<เวลา>.dmp
> clrstack -all          # managed stack ของทุก thread รวม UI thread ที่ค้าง
> clrthreads             # รายการ managed thread และสถานะ

อีกเรื่องที่แก้ไปพร้อมกันคือเดาผิดข้อที่สาม บรรทัด stats ที่เคยออกตามเฟรม ผมย้ายมาออกจากจังหวะ 250 ms ของ watchdog แทน log เลยมีชีพจรทุก 10 วินาทีแม้ไม่มีเฟรมถูกวาดเลย และถ้าหน้าต่างถูกย่ออยู่ บรรทัดนั้นจะเขียนว่า MINIMISED ให้เห็น ครั้งหน้าที่เจอช่องว่างใน log จะแปลความได้ทางเดียว ไม่ต้องเดาอีกว่าเงียบเพราะค้างหรือเงียบเพราะไม่มีอะไรให้วาด

ฝั่งป้องกัน: build ต้องอยู่ต่ำกว่าระบบสด

ต่อให้พิสูจน์ไม่ได้ว่า build เป็นสาเหตุ การปล่อยให้ compiler 14 ตัวแย่ง CPU กับระบบที่กำลังทำงานสดอยู่บนเครื่องเดียวกันก็เป็นความเสี่ยงที่ไม่มีเหตุผลต้องรับ ผมแก้สองทาง

  1. หน้าจอควบคุมกับเอนจินตั้ง priority class เป็น ABOVE_NORMAL ตอนสตาร์ต ไม่ใช้ HIGH หรือ REALTIME เพราะสองระดับนั้นถ้าโปรแกรมเราเองเกิดวนลูป มันจะไปแย่งงานของระบบปฏิบัติการจนเครื่องทั้งเครื่องตอบสนองช้า
  2. สคริปต์ build และ deploy ลด priority ของตัวเองเป็น BELOW_NORMAL ก่อนเรียก compiler บน Windows process ลูกที่ถูกสร้างจากแม่ที่อยู่ระดับ BELOW_NORMAL หรือ IDLE จะได้ระดับเดียวกับแม่โดยปริยาย compiler ทุกตัวเลยลงมาอยู่ระดับเดียวกันโดยไม่ต้องตั้งทีละตัว
  3. จำกัดความขนานของ build ไม่ให้กินครบทุก thread ฝั่ง .NET ใช้ -m:4 ฝั่งเอนจินใช้ 6 jobs ตอน build และ 4 thread ตอนรันเทสต์ บนเครื่อง 16 thread
  4. คืน priority เดิมให้สคริปต์ใน finally เสมอ ไม่งั้นขั้นตอนหลัง build เช่นการสตาร์ตระบบใหม่ จะได้ระดับต่ำติดไปด้วย
# ส่วน build ของสคริปต์ deploy
$me = Get-Process -Id $PID
$prio = $me.PriorityClass
$me.PriorityClass = 'BelowNormal'          # compiler ที่ถูกเรียกต่อจากนี้ได้ระดับเดียวกัน
try {
    cargo build --release -j 6
    if ($LASTEXITCODE -ne 0) { throw 'build เอนจินล้ม' }
    cargo test --release -j 6 -- --test-threads=4
    if ($LASTEXITCODE -ne 0) { throw 'เทสต์เอนจินล้ม' }
    dotnet publish .\ui\Ui.csproj -c Release -m:4
    if ($LASTEXITCODE -ne 0) { throw 'publish หน้าจอล้ม' }
}
finally { $me.PriorityClass = $prio }       # ขั้นตอนถัดไปต้องไม่ติดระดับต่ำไปด้วย
// บรรทัดแรก ๆ ของ Main ทั้งหน้าจอและเอนจิน (ฝั่งเอนจินใช้ API เทียบเท่าในภาษาของมัน)
using (Process me = Process.GetCurrentProcess())
    me.PriorityClass = ProcessPriorityClass.AboveNormal;

เทสต์ของ watchdog เอง

ตัวเฝ้าที่ไม่เคยถูกทดสอบสาขาที่มันมีไว้เพื่อทำงาน คือตัวเฝ้าที่ยังไม่รู้ว่าใช้ได้ไหม เพราะ HangMonitor ไม่มีนาฬิกาของตัวเอง เทสต์เลยป้อนเวลาเป็นตัวเลขได้ตรง ๆ และรันจบในเสี้ยววินาที

[Fact]
public void ReportsAtThreeSeconds_ThenAgainAfterThirty_AndDumpsOnce()
{
    var m = new HangMonitor();
    Assert.True(m.Check(0).Post);                    // โพสต์ #1 แล้วไม่มีใคร ack เลย

    int reports = 0, dumps = 0;
    for (long now = 250; now <= 34_000; now += 250)
    {
        HangMonitor.Step s = m.Check(now);
        if (s.Report) reports++;
        if (s.Dump) dumps++;
    }
    Assert.Equal(2, reports);                        // ที่ 3 วินาที และที่ 33 วินาที
    Assert.Equal(1, dumps);                          // ที่ 10 วินาที ครั้งเดียว
}

[Fact]
public void LateAckEndsTheStallAndReportsItsLength()
{
    var m = new HangMonitor();
    HangMonitor.Step first = m.Check(0);
    for (long now = 250; now <= 5000; now += 250) m.Check(now);

    m.Ack(first.Seq);                                // UI thread กลับมารับข้อความ
    HangMonitor.Step after = m.Check(5250);
    Assert.Equal(5250, after.EndedMs);               // ค้างยาว 5,250 ms นับจากข้อความที่ไม่ถูกรับ
    Assert.True(after.Post);                         // แล้วเริ่มรอบใหม่ด้วยเลขถัดไป
}

ชุดเทสต์ของ watchdog มี 6 ตัว ครอบคลุมค้างครั้งเดียว ค้างแล้วรายงานซ้ำ dump ครั้งเดียวต่อการรัน ค้างจบแล้วมีบรรทัด log ack ที่มาช้า และตัวสุดท้ายใช้ thread จริงที่ไม่ ack เลย เพื่อยืนยันว่าทั้งวงจรทำงานนอกเหนือจากตรรกะล้วน

มีของแถมที่มาจากเรื่องเดียวกัน เทสต์จับเวลาอีกสองตัวในชุดเดิมเคยล้มเป็นครั้งคราวตอนเครื่องโหลดสูง ซึ่งก็คืออาการของเหตุเดียวกันในขนาดย่อ เทสต์ที่วัดเวลาจริงบนเครื่องที่กำลัง build อยู่ บอกอะไรเกี่ยวกับโค้ดได้น้อยกว่าที่บอกเกี่ยวกับเครื่อง

ก่อน

log ที่ขึ้นกับ UI thread

  • stats ออกเมื่อมีเฟรมเท่านั้น
  • เงียบ = ค้าง หรือย่อหน้าต่าง แยกไม่ได้
  • ค้างแล้วไม่มีใครจดอะไร
  • ต้องเดาสาเหตุย้อนหลัง
หลัง

watchdog thread แยก

  • ชีพจรทุก 10 วินาที บอก MINIMISED
  • ค้าง 3 วินาที มีรายงานพร้อมคำตัดสิน
  • ค้าง 10 วินาที มี dump พร้อม stack
  • จบแล้วรู้ว่าค้างนานเท่าไร

สรุปคือเหตุการณ์ครั้งนั้นผมยังตอบไม่ได้ว่าเกิดจากอะไร และจะไม่เขียนว่าตอบได้ สิ่งที่เปลี่ยนคือครั้งถัดไปที่หน้าจอค้างเกิน 3 วินาที log จะมีบรรทัดที่บอกว่า UI thread ใช้ CPU ไปเท่าไร อยู่ในสถานะอะไร เครื่องโหลดแค่ไหน และใครกิน CPU อยู่ ซึ่งพอสำหรับแยกสามทางออกจากกัน ส่วนตัวผมคิดว่าเครื่องมือแบบนี้ควรมีตั้งแต่วันแรกในแอปที่มี UI thread เดียว เพราะราคาของมันคือ thread หนึ่งตัวที่ตื่นทุก 250 ms กับโค้ดไม่กี่ร้อยบรรทัด ใครจะเอาไปใช้ก็ปรับเกณฑ์ 3 วินาทีกับ 60% ตามลักษณะงานของตัวเองได้ตามสะดวกครับ ถ้ารายงานตัวแรกจากของจริงมาถึงเมื่อไร เดี๋ยวกลับมาแก้เพิ่มให้ภายหลังครับ

เคยเจองานแบบนี้ไหม? ติดตรงไหน?

มาแลกวิธีกันต่อในบอร์ด LinuxThai

→ คุยต่อในบอร์ด

ความคิดเห็น 0

ยังไม่มีความคิดเห็น — เป็นคนแรกเลย