เขียนการเปรียบเทียบมาโคร

ใช้ไลบรารี Macrobenchmark เพื่อทดสอบกรณีการใช้งานขนาดใหญ่ของแอป ซึ่งรวมถึงการเริ่มต้นแอปและการจัดการ UI ที่ซับซ้อน เช่น การเลื่อน RecyclerView หรือการเรียกใช้ภาพเคลื่อนไหว หากต้องการทดสอบโค้ดส่วนเล็กๆ ของ คุณ ให้ดูที่ ไลบรารี Microbenchmark หน้านี้แสดงวิธีตั้งค่าไลบรารี Macrobenchmark

ไลบรารีจะแสดงผลการเปรียบเทียบประสิทธิภาพทั้งในคอนโซล Android Studio และไฟล์ JSON ที่มีรายละเอียดเพิ่มเติม นอกจากนี้ยังมีไฟล์การติดตามที่คุณโหลดและวิเคราะห์ใน Android Studio ได้ด้วย

ใช้ไลบรารี Macrobenchmark ในสภาพแวดล้อมการรวมอย่างต่อเนื่อง (CI) ตามที่ อธิบายไว้ใน การเปรียบเทียบประสิทธิภาพในการรวมอย่างต่อเนื่อง

คุณใช้ Macrobenchmark เพื่อสร้างโปรไฟล์พื้นฐานได้ ก่อนอื่นให้ตั้งค่าไลบรารี Macrobenchmark แล้วคุณจะสร้างโปรไฟล์พื้นฐาน ได้

การตั้งค่าโปรเจ็กต์

เราขอแนะนำให้ใช้ Macrobenchmark กับ Android Studio เวอร์ชันล่าสุดสำหรับฟีเจอร์ของ IDE ที่ผสานรวมกับ Macrobenchmark

ตั้งค่าโมดูล Macrobenchmark

Macrobenchmark ต้องใช้ com.android.test โมดูล ซึ่งแยกจากโค้ดแอป และมีหน้าที่เรียกใช้การทดสอบ ที่วัดประสิทธิภาพของแอป

ใน Android Studio มีเทมเพลตให้ใช้เพื่อลดความซับซ้อนในการตั้งค่าโมดูล Macrobenchmark เทมเพลตโมดูลการเปรียบเทียบประสิทธิภาพจะสร้างโมดูลในโปรเจ็กต์โดยอัตโนมัติเพื่อวัดประสิทธิภาพของแอปที่สร้างโดยโมดูลแอป ซึ่งรวมถึงการเปรียบเทียบประสิทธิภาพการเริ่มต้นแอปตัวอย่าง

หากต้องการใช้เทมเพลตโมดูลเพื่อสร้างโมดูลใหม่ ให้ทำดังนี้

1. คลิกขวาที่โปรเจ็กต์หรือโมดูลในแผงโปรเจ็กต์ ใน Android Studio แล้วเลือกใหม่ > โมดูล

2. เลือกการเปรียบเทียบประสิทธิภาพ จากบานหน้าต่างเทมเพลต คุณสามารถปรับแต่งแอปเป้าหมาย ซึ่งหมายถึงแอปที่จะเปรียบเทียบประสิทธิภาพ รวมถึงชื่อแพ็กเกจและโมดูลสำหรับโมดูล Macrobenchmark ใหม่

3. คลิกเสร็จสิ้น

รูปที่ 1 เทมเพลตโมดูลการเปรียบเทียบประสิทธิภาพ

ตั้งค่าแอป

หากต้องการเปรียบเทียบประสิทธิภาพของแอป ซึ่งเรียกว่า เป้าหมายของ Macrobenchmark แอปต้อง profileableซึ่งช่วยให้อ่านข้อมูลการติดตามโดยละเอียดได้โดยไม่ ส่งผลต่อประสิทธิภาพ วิซาร์ดโมดูลจะเพิ่มแท็ก <profileable> ลงในไฟล์ AndroidManifest.xml ของแอปโดยอัตโนมัติ

ตรวจสอบว่าแอปเป้าหมายมี ProfilerInstaller เวอร์ชัน 1.3 หรือ สูงกว่า ซึ่งไลบรารี Macrobenchmark ต้องใช้เพื่อเปิดใช้การจับภาพโปรไฟล์ การ รีเซ็ต และการล้างแคช Shader

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

buildTypes {
    getByName("release") {
        isMinifyEnabled = true
        isShrinkResources = true
        proguardFiles(getDefaultProguardFile("proguard-android-optimize.txt"))
    }

    create("benchmark") {
        initWith(getByName("release"))
        signingConfig = signingConfigs.getByName("debug")
    }
}

buildTypes {
    release {
        isMinifyEnabled = true
        isShrinkResources = true
        proguardFiles(
            getDefaultProguardFile("proguard-android-optimize.txt"),
            "keep-rules.pro"
        )
        // In real app, this would use its own release keystore
        signingConfig = signingConfigs.getByName("debug")
        baselineProfile.automaticGenerationDuringBuild = true
    }
}
build.gradle.kts

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

1. ทำการซิงค์ Gradle
2. เปิดแผงตัวแปรเวอร์ชันบิลด์
3. เลือกตัวแปรเวอร์ชันการเปรียบเทียบประสิทธิภาพของทั้งแอปและโมดูล Macrobenchmark

รูปที่ 2 เลือกตัวแปรเวอร์ชันการเปรียบเทียบประสิทธิภาพ

(ไม่บังคับ) ตั้งค่าแอปแบบหลายโมดูล

หากแอปมีโมดูล Gradle มากกว่า 1 โมดูล ให้ตรวจสอบว่าสคริปต์บิลด์ทราบตัวแปรบิลด์ที่จะคอมไพล์ เพิ่มพร็อพเพอร์ตี้matchingFallbacks ลงในประเภทบิลด์ benchmark ของโมดูล :macrobenchmark และ :app โมดูล Gradle ที่เหลือสามารถมีการกำหนดค่าเหมือนเดิม

create("benchmark") {
    initWith(getByName("release"))
    signingConfig = signingConfigs.getByName("debug")

    matchingFallbacks += listOf("release")
 }

benchmark {
    initWith buildTypes.release
    signingConfig signingConfigs.debug

    matchingFallbacks = ['release']
 }

หากไม่มีพร็อพเพอร์ตี้ดังกล่าว ประเภทบิลด์ benchmark ที่เพิ่มใหม่จะทำให้บิลด์ล้มเหลวและแสดงข้อความแสดงข้อผิดพลาดต่อไปนี้

> Could not resolve project :shared.
     Required by:
         project :app
      > No matching variant of project :shared was found.
      ...

เมื่อเลือกตัวแปรเวอร์ชันบิลด์ในโปรเจ็กต์ ให้เลือก benchmark สำหรับ :app และโมดูล :macrobenchmark และเลือก release สำหรับโมดูลอื่นๆ ที่คุณมีใน แอป ดังที่แสดงในรูปที่ 3

รูปที่ 3 ตัวแปรเวอร์ชันการเปรียบเทียบประสิทธิภาพสำหรับโปรเจ็กต์แบบหลายโมดูลที่มีการเลือกประเภทบิลด์เวอร์ชันที่เผยแพร่และเวอร์ชันการเปรียบเทียบประสิทธิภาพ

ดูข้อมูลเพิ่มเติมได้ที่หัวข้อ ใช้การจัดการทรัพยากร Dependency ที่คำนึงถึงตัวแปรเวอร์ชัน

(ไม่บังคับ) ตั้งค่า Product Flavor

หากคุณตั้งค่าเวอร์ชันผลิตภัณฑ์หลายรายการในแอป ให้กำหนดค่าโมดูล :macrobenchmark เพื่อให้โมดูลทราบเวอร์ชันผลิตภัณฑ์ของแอปที่จะสร้างและเปรียบเทียบประสิทธิภาพ

ตัวอย่างในหน้านี้ใช้ Product Flavor 2 รายการในโมดูล :app ได้แก่ demo และ production ดังที่แสดงในข้อมูลโค้ดต่อไปนี้

flavorDimensions += "environment"
productFlavors {
    create("demo") {
        dimension = "environment"
        // ...
    }
    create("production") {
        dimension = "environment"
        // ...
    }
}

flavorDimensions 'environment'
productFlavors {
    demo {
        dimension 'environment'
        // ...
    }

    production {
        dimension 'environment'
        // ...
    }
}

หากไม่มีการกำหนดค่านี้ คุณอาจได้รับข้อผิดพลาดในการสร้างที่คล้ายกับกรณีที่มีโมดูล Gradle หลายโมดูล

Could not determine the dependencies of task ':macrobenchmark:connectedBenchmarkAndroidTest'.
> Could not determine the dependencies of null.
   > Could not resolve all task dependencies for configuration ':macrobenchmark:benchmarkTestedApks'.
      > Could not resolve project :app.
        Required by:
            project :macrobenchmark
         > The consumer was configured to find a runtime of a component, as well as attribute 'com.android.build.api.attributes.BuildTypeAttr' with value 'benchmark', attribute 'com.android.build.api.attributes.AgpVersionAttr' with value '7.3.0'. However we cannot choose between the following variants of project :app:
             -   demoBenchmarkRuntimeElements
             -   productionBenchmarkRuntimeElements
           All of them match the consumer attributes:
           ...

ส่วนต่อไปนี้แสดงวิธีต่างๆ ในการกำหนดค่าการเปรียบเทียบประสิทธิภาพด้วย Product Flavor หลายรายการ

ใช้ missingDimensionStrategy

การระบุ missingDimensionStrategy ใน defaultConfig ของโมดูล :macrobenchmark จะบอกให้ระบบบิลด์กลับไปใช้มิติข้อมูล Flavor ระบุมิติข้อมูลที่จะใช้หากไม่พบมิติข้อมูลในโมดูล ในตัวอย่างต่อไปนี้ ระบบจะใช้ Flavor production เป็นมิติข้อมูลเริ่มต้น

defaultConfig {
    missingDimensionStrategy("environment", "production")
}

defaultConfig {
    missingDimensionStrategy "environment", "production"
}

วิธีนี้จะช่วยให้โมดูล :macrobenchmark สร้างและเปรียบเทียบประสิทธิภาพเฉพาะเวอร์ชันผลิตภัณฑ์ที่ระบุได้ ซึ่งเป็นประโยชน์หากคุณทราบว่ามีเพียงเวอร์ชันผลิตภัณฑ์เดียวที่มีการกำหนดค่าที่เหมาะสมสำหรับการเปรียบเทียบประสิทธิภาพ

กำหนด Product Flavor ในโมดูล :macrobenchmark

หากต้องการสร้างและเปรียบเทียบประสิทธิภาพเวอร์ชันผลิตภัณฑ์อื่นๆ ให้กำหนดเวอร์ชันผลิตภัณฑ์เหล่านั้นในโมดูล :macrobenchmark ระบุ Product Flavor ในลักษณะเดียวกับในโมดูล :app แต่กำหนด productFlavors ให้กับ dimension เท่านั้น ไม่จำเป็นต้องมีการตั้งค่าอื่นๆ

flavorDimensions += "environment"
productFlavors {
    create("demo") {
        dimension = "environment"
    }
    create("production") {
        dimension = "environment"
    }
}

flavorDimensions 'environment'
productFlavors {
    demo {
        dimension 'environment'
    }

    production {
        dimension 'environment'
    }
}

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

รูปที่ 4 ตัวแปรเวอร์ชันการเปรียบเทียบประสิทธิภาพสำหรับโปรเจ็กต์ที่มี Product Flavor ซึ่งแสดง "productionBenchmark" และ "release" ที่เลือก

ดูข้อมูลเพิ่มเติมได้ที่หัวข้อ แก้ไขข้อผิดพลาดในการสร้างที่เกี่ยวข้องกับการจับคู่ตัวแปร

สร้างคลาส Macrobenchmark

การทดสอบการเปรียบเทียบประสิทธิภาพมีให้ใช้งานผ่าน MacrobenchmarkRule กฎ JUnit4 API ในไลบรารี Macrobenchmark ซึ่งมีเมธอด measureRepeated ที่ช่วยให้คุณระบุเงื่อนไขต่างๆ เกี่ยวกับวิธีเรียกใช้และเปรียบเทียบประสิทธิภาพของแอปเป้าหมาย ได้

คุณต้องระบุ packageName ของแอปเป้าหมาย metrics ที่ต้องการวัด และจำนวน iterations ที่การเปรียบเทียบประสิทธิภาพต้องเรียกใช้ อย่างน้อย

@LargeTest
@RunWith(AndroidJUnit4::class)
class SampleStartupBenchmark {
    @get:Rule
    val benchmarkRule = MacrobenchmarkRule()

    @Test
    fun startup() = benchmarkRule.measureRepeated(
        packageName = TARGET_PACKAGE,
        metrics = listOf(StartupTimingMetric()),
        iterations = DEFAULT_ITERATIONS,
    ) {
        // starts default launch activity
        uiAutomator { startApp(TARGET_PACKAGE) }
    }
}
SampleStartupBenchmark.kt

@LargeTest
@RunWith(AndroidJUnit4.class)
public class SampleStartupBenchmark {
    @Rule
    public MacrobenchmarkRule benchmarkRule = new MacrobenchmarkRule();

    @Test
    public void startup() {
        benchmarkRule.measureRepeated(
            /* packageName */ TARGET_PACKAGE,
            /* metrics */ Arrays.asList(new StartupTimingMetric()),
            /* iterations */ 5,
            /* measureBlock */ scope -> {
                // starts default launch activity
                scope.startActivityAndWait();
                return Unit.INSTANCE;
            }
        );
    }
}

ดูตัวเลือกทั้งหมดในการปรับแต่งการเปรียบเทียบประสิทธิภาพได้ที่ส่วนปรับแต่งการ เปรียบเทียบประสิทธิภาพ

เรียกใช้การเปรียบเทียบประสิทธิภาพ

เรียกใช้การทดสอบจากภายใน Android Studio เพื่อวัดประสิทธิภาพของแอปในอุปกรณ์ คุณสามารถเรียกใช้การเปรียบเทียบประสิทธิภาพด้วยวิธีเดียวกับที่เรียกใช้ @Test อื่นๆ โดยใช้การดำเนินการ Gutter ข้างคลาสหรือเมธอดการทดสอบ ดังที่แสดงในรูปที่ 5

รูปที่ 5 เรียกใช้ Macrobenchmark ด้วยการดำเนินการ Gutter ข้างคลาสการทดสอบ

นอกจากนี้ คุณยังเรียกใช้การเปรียบเทียบประสิทธิภาพทั้งหมดในโมดูล Gradle จากบรรทัดคำสั่งได้โดยการเรียกใช้คำสั่ง connectedCheck

./gradlew :macrobenchmark:connectedCheck

คุณเรียกใช้การทดสอบรายการเดียวได้โดยเรียกใช้คำสั่งต่อไปนี้

./gradlew :macrobenchmark:connectedCheck -P android.testInstrumentationRunnerArguments.class=com.example.macrobenchmark.startup.SampleStartupBenchmark#startup

ดูข้อมูลเกี่ยวกับวิธีเรียกใช้และ ตรวจสอบการเปรียบเทียบประสิทธิภาพในการรวมอย่างต่อเนื่องได้ที่หัวข้อการเปรียบเทียบประสิทธิภาพในการรวมอย่างต่อเนื่อง

ผลการเปรียบเทียบประสิทธิภาพ

หลังจากเรียกใช้การเปรียบเทียบประสิทธิภาพสำเร็จแล้ว ระบบจะแสดงเมตริกใน Android Studio โดยตรงและแสดงผลใน ไฟล์ JSON สำหรับการใช้งาน CI การทำซ้ำที่วัดแต่ละครั้งจะจับภาพการติดตามระบบแยกกัน คุณสามารถเปิดผลการติดตามเหล่านี้ได้โดยคลิกลิงก์ในบานหน้าต่างผลการทดสอบ ดังที่แสดงในรูปที่ 6

รูปที่ 6 ผลการเริ่มต้น Macrobenchmark

เมื่อโหลดการติดตามแล้ว Android Studio จะแจ้งให้คุณเลือกกระบวนการที่จะวิเคราะห์ ระบบจะป้อนข้อมูลกระบวนการของแอปเป้าหมายไว้ล่วงหน้า ดังที่แสดงในรูปที่ 7

รูปที่ 7 การเลือกกระบวนการติดตาม Studio

หลังจากโหลดไฟล์การติดตามแล้ว Studio จะแสดงผลลัพธ์ในเครื่องมือโปรไฟล์ CPU:

รูปที่ 8 การติดตาม Studio

นอกจากนี้ ระบบยังคัดลอกรายงาน JSON และการติดตามการสร้างโปรไฟล์จากอุปกรณ์ไปยังโฮสต์โดยอัตโนมัติด้วย โดยจะเขียนในเครื่องโฮสต์ในตำแหน่งต่อไปนี้

project_root/module/build/outputs/connected_android_test_additional_output/debugAndroidTest/connected/device_id/

เข้าถึงไฟล์การติดตามด้วยตนเอง

หากต้องการใช้เครื่องมือ Perfetto เพื่อวิเคราะห์ไฟล์การติดตาม คุณต้องทำตามขั้นตอนเพิ่มเติม Perfetto ช่วยให้คุณตรวจสอบกระบวนการทั้งหมดที่เกิดขึ้นในอุปกรณ์ระหว่างการติดตามได้ ในขณะที่โปรไฟล์ CPU ของ Android Studio จำกัดการตรวจสอบไว้ที่กระบวนการเดียว

หากคุณเรียกใช้การทดสอบจาก Android Studio หรือจากบรรทัดคำสั่ง Gradle ระบบจะคัดลอกไฟล์การติดตามจากอุปกรณ์ไปยังโฮสต์โดยอัตโนมัติ โดยจะเขียนในเครื่องโฮสต์ในตำแหน่งต่อไปนี้

project_root/module/build/outputs/connected_android_test_additional_output/debugAndroidTest/connected/device_id/TrivialStartupBenchmark_startup[mode=COLD]_iter002.perfetto-trace

เมื่อมีไฟล์การติดตามในระบบโฮสต์แล้ว คุณจะเปิดไฟล์ดังกล่าวใน Android Studio ได้โดยเลือกไฟล์ > เปิด ในเมนู ซึ่งจะแสดงมุมมองเครื่องมือโปรไฟล์ที่แสดงในส่วนก่อนหน้า

ข้อผิดพลาดในการกำหนดค่า

หากแอปมีการกำหนดค่าไม่ถูกต้อง เช่น สามารถแก้ไขข้อบกพร่องได้หรือไม่สามารถสร้างโปรไฟล์ได้ Macrobenchmark จะแสดงข้อผิดพลาดแทนที่จะรายงานการวัดที่ไม่ถูกต้องหรือไม่สมบูรณ์ คุณสามารถ ระงับข้อผิดพลาดเหล่านี้ได้ด้วยandroidx.benchmark.suppressErrors อาร์กิวเมนต์

นอกจากนี้ Macrobenchmark ยังแสดงข้อผิดพลาดเมื่อพยายามวัดประสิทธิภาพของโปรแกรมจำลองหรืออุปกรณ์ที่แบตเตอรี่เหลือน้อย ซึ่งอาจส่งผลต่อความพร้อมใช้งานของคอร์และความเร็วสัญญาณนาฬิกา

ปรับแต่งการเปรียบเทียบประสิทธิภาพ

ฟังก์ชัน measureRepeated ยอมรับพารามิเตอร์ต่างๆ ที่ส่งผลต่อ เมตริกที่ไลบรารีรวบรวม วิธีเริ่มต้นและคอมไพล์แอป หรือ จำนวนการทำซ้ำที่การเปรียบเทียบประสิทธิภาพเรียกใช้

จับภาพเมตริก

เมตริกเป็นข้อมูลประเภทหลักที่แยกออกมาจากการเปรียบเทียบประสิทธิภาพ เมตริกที่พร้อมให้คุณใช้งานมีดังนี้

• StartupTimingMetric
• FrameTimingMetric
• TraceSectionMetric

ดูข้อมูลเพิ่มเติมเกี่ยวกับเมตริกได้ที่หัวข้อจับภาพเมตริก Macrobenchmark

ปรับปรุงข้อมูลการติดตามด้วยเหตุการณ์ที่กำหนดเอง

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

CompilationMode

Macrobenchmark สามารถระบุ CompilationMode ซึ่งกำหนดปริมาณของ แอปที่ต้องคอมไพล์ล่วงหน้าจากไบต์โค้ด DEX (รูปแบบไบต์โค้ดภายใน APK) เป็นรหัสเครื่อง (คล้ายกับ C++ ที่คอมไพล์ล่วงหน้า)

โดยค่าเริ่มต้น Macrobenchmark จะเรียกใช้ด้วย CompilationMode.DEFAULT ซึ่งจะติดตั้งโปรไฟล์พื้นฐาน (หากมี) ใน Android 7 (ระดับ API 24) ขึ้นไป หากคุณใช้ Android 6 (ระดับ API 23) ลงไป โหมดการคอมไพล์จะคอมไพล์ APK อย่างสมบูรณ์ตามลักษณะการทำงานเริ่มต้นของระบบ

คุณสามารถติดตั้งโปรไฟล์พื้นฐานได้หากแอปเป้าหมายมีทั้งโปรไฟล์พื้นฐาน และไลบรารี ProfileInstaller

ใน Android 7 ขึ้นไป คุณสามารถปรับแต่ง CompilationMode เพื่อส่งผลต่อปริมาณการคอมไพล์ล่วงหน้าในอุปกรณ์เพื่อจำลองการคอมไพล์ล่วงหน้า (AOT) หรือการแคช JIT ในระดับต่างๆ ดู CompilationMode.Full, CompilationMode.Partial, CompilationMode.None และ CompilationMode.Ignore

ฟีเจอร์นี้สร้างขึ้นจากคำสั่งการคอมไพล์ ART การเปรียบเทียบประสิทธิภาพแต่ละครั้งจะล้างข้อมูลโปรไฟล์ก่อนที่จะเริ่ม เพื่อช่วยให้แน่ใจว่าการเปรียบเทียบประสิทธิภาพจะไม่รบกวนกัน

StartupMode

หากต้องการเริ่มกิจกรรม คุณสามารถส่งโหมดการเริ่มต้นที่กำหนดไว้ล่วงหน้า ได้แก่ COLD, WARM หรือ HOT พารามิเตอร์นี้จะเปลี่ยนวิธีเปิดกิจกรรมและสถานะกระบวนการเมื่อเริ่มการทดสอบ

ดูข้อมูลเพิ่มเติมเกี่ยวกับประเภทการเริ่มต้นได้ที่หัวข้อเวลาที่ใช้ในการเริ่มต้นแอป

ตัวอย่าง

โปรเจ็กต์ตัวอย่างมีให้ใช้งานใน Macrobenchmark Sample ของที่เก็บใน GitHub

แสดงความคิดเห็น

หากต้องการรายงานปัญหาหรือส่งคำขอฟีเจอร์สำหรับ Jetpack Macrobenchmark โปรดดู เครื่องมือติดตามปัญหา แบบสาธารณะ