【车载性能优化】将线程&进程运行在期望的CPU核心上

简介: 如果我们能够将程序的**进程**或**线程**运行在指定的CPU核心上,原则上就可以实现动态调节应用的执行效率。实现这种需求要用到一个Linux的函数—`sched_setaffinity`。

车载Android应用开发中,可能会出现一种奇葩的要求:与用户交互时应用需要全速运行,保证交互的流畅性,但是如果应用进入后台就需要怠速运行,让出更多的资源保证系统或前台应用的流畅度。那么基于这种需求,我们需要实现一种可以动态调节应用执行效率的框架。

众所周知,当前使用最广泛的车载SOC-高通骁龙8155,采用1+3+4的8核心设计,其中大核主频为 2.96GHz,三个高性能核心主频为 2.42GHz,四个低功耗核心主频为 1.8GHz。

如果我们能够将程序的进程线程运行在指定的CPU核心上,原则上就可以实现动态调节应用的执行效率。实现这种需求要用到一个Linux的函数—sched_setaffinity

这里的芯片规格数据源自中文互联网,与我个人接触到的骁龙SA8155P量产型的实际频率存在不小的出入。

sched_setaffinity简介

在介绍sched_setaffinity之前,需要先介绍一个新概念 - CPU 亲和性

CPU亲和性

CPU亲和性是指进程或线程在运行时倾向于在某个或某些CPU核心上执行,而不是随机或频繁地在不同的核心之间切换。CPU亲和性可以提高进程或线程的性能,因为它可以利用CPU缓存的局部性,减少缓存失效和进程迁移的开销。

CPU亲和性分为软亲和性硬亲和性

  • 软亲和性是Linux内核进程调度器的默认特性,它会尽量让进程在上次运行的CPU核心上继续运行,但不保证一定如此,因为还要考虑各个核心的负载均衡。
  • 硬亲和性是Linux内核提供给用户的API,它可以让用户显式地指定进程或线程可以运行在哪些CPU核心上,或者绑定到某个特定的核心上。

在Linux内核系统上,要设置或获取CPU亲和性,可以使用以下函数:

  • sched_setaffinity():设置进程或线程的CPU亲和性掩码,表示它可以运行在哪些核心上。
  • sched_getaffinity():获取进程或线程的CPU亲和性掩码,表示它当前可以运行在哪些核心上。
  • CPU_ZERO():操作CPU亲和性掩码的宏,用于清空某个核心是否在掩码中。
  • CPU_SET():操作CPU亲和性掩码的宏,用于设置某个核心是否在掩码中。
  • CPU_CLR():操作CPU亲和性掩码的宏,用于清除某个核心是否在掩码中。
  • CPU_ISSET():操作CPU亲和性掩码的宏,用于检查某个核心是否在掩码中。

使用方式

第一步:创建一个cpu_set_t类型的变量mask,用于表示CPU亲和性掩码。

第二步:然后使用CPU_ZEROCPU_SET宏来清空和设置mask,使得只有core对应的位为1,其他位为0。

第三步:调用sched_setaffinity函数来设置当前线程的CPU亲和性,如果成功返回0,否则返回-1。

    // cpu 亲和性掩码
    cpu_set_t mask;
    // 清空
    CPU_ZERO(&mask);
    // 设置 亲和性掩码
    CPU_SET(core, &mask);
    // 设置当前线程的cpu亲和性
    if (sched_setaffinity(0, sizeof(mask), &mask) == -1) {
        return -1;
    }

sched_setaffinity函数的原理是通过设置进程或线程的CPU亲和性掩码,来指定它可以运行在哪些CPU核心上。CPU亲和性掩码是一个位图,每一位对应一个CPU核心,如果某一位为1,表示该进程或线程可以运行在该核心上,否则不能。

sched_setaffinity函数可以用于提高进程或线程的性能,避免频繁地在不同的核心之间切换。

sched_setaffinity函数的原型如下:

int sched_setaffinity(pid_t pid, size_t cpusetsize, const cpu_set_t *mask);

pid:表示要设置的进程或线程的ID,如果为0,则表示当前进程或线程;

cpusetsize:表示mask指针指向的数据的长度,通常为sizeof(cpu_set_t);

mask:是一个指向cpu_set_t类型的指针,cpu_set_t是一个不透明的结构体,用于表示CPU亲和性掩码,需要使用一些宏来操作它,如CPU_ZERO, CPU_SET, CPU_CLR等。

sched_setaffinity函数成功时返回0,失败时返回-1,并设置errno为相应的错误码。可能的错误码有:

  • EFAULT: mask指针无效
  • EINVAL: mask中没有有效的CPU核心
  • EPERM: 调用者没有足够的权限

Android实现

在Android 应用中我们需要借助JNI来调用sched_setaffinity函数。使用AndroidStudio创建一个NDK的默认工程,Cmake脚本如下:

cmake_minimum_required(VERSION 3.22.1)

project("socaffinity")

add_library(${CMAKE_PROJECT_NAME} SHARED
        native-lib.cpp)

target_link_libraries(${CMAKE_PROJECT_NAME}
        android
        log)

Native-lib源码如下:

#include <jni.h>
#include <unistd.h>
#include <pthread.h>

// 获取cpu核心数
int getCores() {
    int cores = sysconf(_SC_NPROCESSORS_CONF);
    return cores;
}

extern "C" JNIEXPORT jint JNICALL Java_com_wj_socaffinity_ThreadAffinity_getCores(JNIEnv *env, jobject thiz){
    return getCores();
}
// 绑定线程到指定cpu
extern "C" JNIEXPORT jint JNICALL Java_com_wj_socaffinity_ThreadAffinity_bindThreadToCore(JNIEnv *env, jobject thiz, jint core) {
    int num = getCores();
    if (core >= num) {
        return -1;
    }
    cpu_set_t mask;
    CPU_ZERO(&mask);
    CPU_SET(core, &mask);
    if (sched_setaffinity(0, sizeof(mask), &mask) == -1) {
        return -1;
    }
    return 0;
}

// 绑定进程程到指定cpu
extern "C"
JNIEXPORT jint JNICALL
Java_com_wj_socaffinity_ThreadAffinity_bindPidToCore(JNIEnv *env, jobject thiz, jint pid,
                                                     jint core) {
    int num = getCores();
    if (core >= num) {
        return -1;
    }
    cpu_set_t mask;
    CPU_ZERO(&mask);
    CPU_SET(core, &mask);
    if (sched_setaffinity(pid, sizeof(mask), &mask) == -1) {
        return -1;
    }
    return 0;
}

然后再将JNI调用方法,封装在一个独立的单例中,如下所示:

object ThreadAffinity {

    private external fun getCores(): Int

    private external fun bindThreadToCore(core: Int): Int

    private external fun bindPidToCore(pid: Int, core: Int): Int

    init {
        System.loadLibrary("socaffinity")
    }

    fun getCoresCount(): Int {
        return getCores()
    }

    fun threadToCore(core: Int, block: () -> Unit) {
        bindThreadToCore(core)
        block()
    }

    fun pidToCore(pid: Int, core: Int){
        bindPidToCore(pid, core)
    }

}

通过上面的代码,我们就是实现了一个最简单的修改CPU亲和性的demo。接下来我们来运行测试。

运行测试

假设有两个需要密集计算的任务,分别为Task1和Task2,逻辑都是计算从0到1000000000的累加和,然后把将消耗时间输出在控制台上。测试代码如下:

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    binding = ActivityMainBinding.inflate(layoutInflater)
    setContentView(binding.root)
    task1()
    task2()
}

// 耗时任务1
private fun task1() {
    Thread {
        var time = System.currentTimeMillis()
        var sum = 0L
        for (i in 0..1000000000L) {
            sum += i
        }
        time = System.currentTimeMillis() - time
        Log.e("SOC_", "start1: $time")
        runOnUiThread {
            binding.sampleText.text = time.toString()
        }
    }.start()
}

// 耗时任务2
private fun task2() {
    Thread {
        var time = System.currentTimeMillis()
        var sum = 0L
        for (i in 0..1000000000L) {
            sum += i
        }
        time = System.currentTimeMillis() - time
        Log.e("SOC_", "start2: $time")
        runOnUiThread {
            binding.sampleText.text = time.toString()
        }
    }.start()
}

情景一:不做任何处理,直接执行耗时任务

该场景下,我们不做额外操作,线程调度采用Android内核默认的方式,得到如下结果:

耗时任务散布在不同的CPU上执行,此时CPU峰值约为207 / 600 %

Task1耗时4037ms,Task2耗时4785ms

情景二:将进程绑定到小核心上

该场景下,我们使用ThreadAffinity将应用进程绑定CPU5上(在我的设备上CPU4、CPU5都是小核心)。

class MyApp: Application() {

    override fun onCreate() {
        // 注意确定你的CPU核心 大核心、小核心的标号。
        ThreadAffinity.pidToCore(android.os.Process.myPid(), 5)
        super.onCreate()
    }

}

耗时任务基本聚集在CPU5上执行,此时CPU峰值约为102 / 600 %

Task1耗时18276ms,Task2耗时18272ms。可以看出这种方式虽然显著降低了CPU峰值,但是任务的执行效率也剧烈下降了。

情景三:将进程、耗时任务绑定到大核心上

该场景下,将进程绑定在CPU2上,Task1、Task2分别绑定在CPU0和CPU1上(在我的设备上,CPU0-CPU3都属于大核心)。

class MyApp: Application() {

    override fun onCreate() {
        // 注意确定你的CPU核心 大核心、小核心的标号。
        ThreadAffinity.pidToCore(android.os.Process.myPid(), 2)
        super.onCreate()
    }
}
private fun start1() {
    // 将线程绑定到核心0上
    ThreadAffinity.threadToCore(0) {
        Thread {
            var time = System.currentTimeMillis()
            var sum = 0L
            for (i in 0..1000000000L) {
                sum += i
            }
            time = System.currentTimeMillis() - time
            Log.e("SOC_", "start1: $time")
            runOnUiThread {
                binding.sampleText.text = time.toString()
            }
        }.start()
    }
}

private fun start2() {
    // 将线程绑定到核心1上
    ThreadAffinity.threadToCore(1) {
        Thread {
            var time = System.currentTimeMillis()
            var sum = 0L
            for (i in 0..1000000000L) {
                sum += i
            }
            time = System.currentTimeMillis() - time
            Log.e("SOC_", "start2: $time")
            runOnUiThread {
                binding.sampleText.text = time.toString()
            }
        }.start()
    }
}

耗时任务基本聚集在CPU0和CPU1上执行,此时CPU峰值约为193 / 600 %

Jul-21-2023 10-15-25.gif

Task1耗时3193ms,Task2耗时3076ms。可以看出相比于Android内核的默认性能调度,手动分配核心可以获得更高的执行效率。

综合上述三种情况我们可以得到以下结论:

  1. 进程绑定到小核心上会显著降低CPU峰值消耗,压制应用消耗系统资源,但是也会拖慢应用程序的执行效率。
  2. 线程指定到不同线程上执行,可以在尽量不提高CPU峰值的情况下,提升应用程序的执行效率。

总结

本文介绍了使用动态调节CPU亲和性的方法,原本是我个人用于车载Android应用性能优化的一种尝试,本身带有一定的「实验性」,具体的缺点相信会在以后地运用中进一步显现,所以目前仅供参考。

请注意以下两点,第一,如果需要运用在你项目中,切记要与所有的应用开发进行协调,尽可能小规模地使用在一些对性能非常敏感的应用上,防止出现大量应用争抢某个CPU的情况。第二,本文介绍的方法不适用于手机,因为手机厂商对于内核的修改,导致不同品牌设备间的CPU调度策略并不一致,在手机上使用可能会失效。

以上就是本篇文章所有的内容了,感谢你的阅读,希望对你有所帮助。

本文中源码地址:https://github.com/linxu-link/SocAffinity

参考资料

Linux中CPU亲和性(affinity)

CPU亲和性的使用与机制

C++性能榨汁机之CPU亲和性

目录
相关文章
|
30天前
|
消息中间件 并行计算 安全
进程、线程、协程
【10月更文挑战第16天】进程、线程和协程是计算机程序执行的三种基本形式。进程是操作系统资源分配和调度的基本单位,具有独立的内存空间,稳定性高但资源消耗大。线程是进程内的执行单元,共享内存,轻量级且并发性好,但同步复杂。协程是用户态的轻量级调度单位,适用于高并发和IO密集型任务,资源消耗最小,但不支持多核并行。
43 1
|
1月前
线程CPU异常定位分析
【10月更文挑战第3天】 开发过程中会出现一些CPU异常升高的问题,想要定位到具体的位置就需要一系列的分析,记录一些分析手段。
63 0
|
9天前
|
并行计算 数据处理 调度
Python中的并发编程:探索多线程与多进程的奥秘####
本文深入探讨了Python中并发编程的两种主要方式——多线程与多进程,通过对比分析它们的工作原理、适用场景及性能差异,揭示了在不同应用需求下如何合理选择并发模型。文章首先简述了并发编程的基本概念,随后详细阐述了Python中多线程与多进程的实现机制,包括GIL(全局解释器锁)对多线程的影响以及多进程的独立内存空间特性。最后,通过实例演示了如何在Python项目中有效利用多线程和多进程提升程序性能。 ####
|
14天前
|
Linux 调度 C语言
深入理解操作系统:进程和线程的管理
【10月更文挑战第32天】本文旨在通过浅显易懂的语言和实际代码示例,带领读者探索操作系统中进程与线程的奥秘。我们将从基础知识出发,逐步深入到它们在操作系统中的实现和管理机制,最终通过实践加深对这一核心概念的理解。无论你是编程新手还是希望复习相关知识的资深开发者,这篇文章都将为你提供有价值的见解。
|
11天前
|
Java
java小知识—进程和线程
进程 进程是程序的一次执行过程,是系统运行的基本单位,因此进程是动态的。系统运行一个程序即是一个进程从创建,运行到消亡的过程。简单来说,一个进程就是一个执行中的程序,它在计算机中一个指令接着一个指令地执行着,同时,每个进程还占有某些系统资源如CPU时间,内存空间,文件,文件,输入输出设备的使用权等等。换句话说,当程序在执行时,将会被操作系统载入内存中。 线程 线程,与进程相似,但线程是一个比进程更小的执行单位。一个进程在其执行的过程中产生多个线程。与进程不同的是同类的多个线程共享同一块内存空间和一组系统资源,所以系统在产生一个线程,或是在各个线程之间做切换工作时,负担要比
22 1
|
16天前
深入理解操作系统:进程与线程的管理
【10月更文挑战第30天】操作系统是计算机系统的核心,它负责管理计算机硬件资源,为应用程序提供基础服务。本文将深入探讨操作系统中进程和线程的概念、区别以及它们在资源管理中的作用。通过本文的学习,读者将能够更好地理解操作系统的工作原理,并掌握进程和线程的管理技巧。
33 2
|
17天前
|
调度 Python
深入浅出操作系统:进程与线程的奥秘
【10月更文挑战第28天】在数字世界的幕后,操作系统悄无声息地扮演着关键角色。本文将拨开迷雾,深入探讨操作系统中的两个基本概念——进程和线程。我们将通过生动的比喻和直观的解释,揭示它们之间的差异与联系,并展示如何在实际应用中灵活运用这些知识。准备好了吗?让我们开始这段揭秘之旅!
|
1月前
|
存储 消息中间件 人工智能
进程,线程,协程 - 你了解多少?
本故事采用简洁明了的对话方式,尽洪荒之力让你在轻松无负担的氛围中,稍微深入地理解进程、线程和协程的相关原理知识
41 2
进程,线程,协程 - 你了解多少?
|
28天前
|
Python
Python中的多线程与多进程
本文将探讨Python中多线程和多进程的基本概念、使用场景以及实现方式。通过对比分析,我们将了解何时使用多线程或多进程更为合适,并提供一些实用的代码示例来帮助读者更好地理解这两种并发编程技术。
|
30天前
|
消息中间件 并行计算 安全
进程、线程、协程
【10月更文挑战第15天】进程、线程和协程是操作系统中三种不同的执行单元。进程是资源分配和调度的基本单位,每个进程有独立的内存空间;线程是进程内的执行路径,共享进程资源,切换成本较低;协程则更轻量,由用户态调度,适合处理高并发和IO密集型任务。进程提供高隔离性和安全性,线程支持高并发,协程则在资源消耗和调度灵活性方面表现优异。
45 2