Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 5fcf72fa authored by Ken Chen's avatar Ken Chen Committed by Automerger Merge Worker
Browse files

Merge changes from topics "gpuMem", "timeInState" am: db8f9c58 am:... 

Merge changes from topics "gpuMem", "timeInState" am: db8f9c58 am: e38da314 am: 8074308b am: da5299f1

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/2149414



Change-Id: If044f45bd8f6d635bbd7a44dc1216c6ef0b956a4
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 525fdadd da5299f1

libs/cputimeinstate/cputimeinstate.cpp

+16 −16
Original line number Diff line number Diff line
@@ -131,24 +131,24 @@ static bool initGlobals() { 
    }



    gTisTotalMapFd =

            unique_fd{bpf_obj_get(BPF_FS_PATH "map_time_in_state_total_time_in_state_map")};

            unique_fd{bpf_obj_get(BPF_FS_PATH "map_timeInState_total_time_in_state_map")};

    if (gTisTotalMapFd < 0) return false;



    gTisMapFd = unique_fd{bpf_obj_get(BPF_FS_PATH "map_time_in_state_uid_time_in_state_map")};

    gTisMapFd = unique_fd{bpf_obj_get(BPF_FS_PATH "map_timeInState_uid_time_in_state_map")};

    if (gTisMapFd < 0) return false;



    gConcurrentMapFd =

            unique_fd{bpf_obj_get(BPF_FS_PATH "map_time_in_state_uid_concurrent_times_map")};

            unique_fd{bpf_obj_get(BPF_FS_PATH "map_timeInState_uid_concurrent_times_map")};

    if (gConcurrentMapFd < 0) return false;



    gUidLastUpdateMapFd =

            unique_fd{bpf_obj_get(BPF_FS_PATH "map_time_in_state_uid_last_update_map")};

            unique_fd{bpf_obj_get(BPF_FS_PATH "map_timeInState_uid_last_update_map")};

    if (gUidLastUpdateMapFd < 0) return false;



    gPidTisMapFd = unique_fd{mapRetrieveRO(BPF_FS_PATH "map_time_in_state_pid_time_in_state_map")};

    gPidTisMapFd = unique_fd{mapRetrieveRO(BPF_FS_PATH "map_timeInState_pid_time_in_state_map")};

    if (gPidTisMapFd < 0) return false;



    unique_fd trackedPidMapFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_pid_tracked_map"));

    unique_fd trackedPidMapFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_pid_tracked_map"));

    if (trackedPidMapFd < 0) return false;



    gInitialized = true;
@@ -156,7 +156,7 @@ static bool initGlobals() { 
}



static int retrieveProgramFd(const std::string &eventType, const std::string &eventName) {

    std::string path = StringPrintf(BPF_FS_PATH "prog_time_in_state_tracepoint_%s_%s",

    std::string path = StringPrintf(BPF_FS_PATH "prog_timeInState_tracepoint_%s_%s",

                                    eventType.c_str(), eventName.c_str());

    return retrieveProgram(path.c_str());

}
@@ -200,7 +200,7 @@ bool startTrackingUidTimes() { 
    if (!initGlobals()) return false;

    if (gTracking) return true;



    unique_fd cpuPolicyFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_cpu_policy_map"));

    unique_fd cpuPolicyFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_cpu_policy_map"));

    if (cpuPolicyFd < 0) return false;



    for (uint32_t i = 0; i < gPolicyCpus.size(); ++i) {
@@ -209,7 +209,7 @@ bool startTrackingUidTimes() { 
        }

    }



    unique_fd freqToIdxFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_freq_to_idx_map"));

    unique_fd freqToIdxFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_freq_to_idx_map"));

    if (freqToIdxFd < 0) return false;

    freq_idx_key_t key;

    for (uint32_t i = 0; i < gNPolicies; ++i) {
@@ -224,23 +224,23 @@ bool startTrackingUidTimes() { 
        }

    }



    unique_fd cpuLastUpdateFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_cpu_last_update_map"));

    unique_fd cpuLastUpdateFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_cpu_last_update_map"));

    if (cpuLastUpdateFd < 0) return false;

    std::vector<uint64_t> zeros(get_nprocs_conf(), 0);

    uint32_t zero = 0;

    if (writeToMapEntry(cpuLastUpdateFd, &zero, zeros.data(), BPF_ANY)) return false;



    unique_fd nrActiveFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_nr_active_map"));

    unique_fd nrActiveFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_nr_active_map"));

    if (nrActiveFd < 0) return false;

    if (writeToMapEntry(nrActiveFd, &zero, &zero, BPF_ANY)) return false;



    unique_fd policyNrActiveFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_policy_nr_active_map"));

    unique_fd policyNrActiveFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_policy_nr_active_map"));

    if (policyNrActiveFd < 0) return false;

    for (uint32_t i = 0; i < gNPolicies; ++i) {

        if (writeToMapEntry(policyNrActiveFd, &i, &zero, BPF_ANY)) return false;

    }



    unique_fd policyFreqIdxFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_policy_freq_idx_map"));

    unique_fd policyFreqIdxFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_policy_freq_idx_map"));

    if (policyFreqIdxFd < 0) return false;

    for (uint32_t i = 0; i < gNPolicies; ++i) {

        auto freqIdx = getPolicyFreqIdx(i);
@@ -560,10 +560,10 @@ bool startTrackingProcessCpuTimes(pid_t pid) { 
    if (!gInitialized && !initGlobals()) return false;



    unique_fd trackedPidHashMapFd(

            mapRetrieveWO(BPF_FS_PATH "map_time_in_state_pid_tracked_hash_map"));

            mapRetrieveWO(BPF_FS_PATH "map_timeInState_pid_tracked_hash_map"));

    if (trackedPidHashMapFd < 0) return false;



    unique_fd trackedPidMapFd(mapRetrieveWO(BPF_FS_PATH "map_time_in_state_pid_tracked_map"));

    unique_fd trackedPidMapFd(mapRetrieveWO(BPF_FS_PATH "map_timeInState_pid_tracked_map"));

    if (trackedPidMapFd < 0) return false;



    for (uint32_t index = 0; index < MAX_TRACKED_PIDS; index++) {
@@ -590,7 +590,7 @@ bool startAggregatingTaskCpuTimes(pid_t pid, uint16_t aggregationKey) { 
    if (!gInitialized && !initGlobals()) return false;



    unique_fd taskAggregationMapFd(

            mapRetrieveWO(BPF_FS_PATH "map_time_in_state_pid_task_aggregation_map"));

            mapRetrieveWO(BPF_FS_PATH "map_timeInState_pid_task_aggregation_map"));

    if (taskAggregationMapFd < 0) return false;



    return writeToMapEntry(taskAggregationMapFd, &pid, &aggregationKey, BPF_ANY) == 0;

libs/cputimeinstate/testtimeinstate.cpp

+3 −3
Original line number Diff line number Diff line
@@ -462,7 +462,7 @@ TEST_F(TimeInStateTest, AllUidConcurrentTimesFailsOnInvalidBucket) { 
        ++uid;

    }

    android::base::unique_fd fd{

        bpf_obj_get(BPF_FS_PATH "map_time_in_state_uid_concurrent_times_map")};

        bpf_obj_get(BPF_FS_PATH "map_timeInState_uid_concurrent_times_map")};

    ASSERT_GE(fd, 0);

    uint32_t nCpus = get_nprocs_conf();

    uint32_t maxBucket = (nCpus - 1) / CPUS_PER_ENTRY;
@@ -504,7 +504,7 @@ TEST_F(TimeInStateTest, RemoveUid) { 
    {

        // Add a map entry for our fake UID by copying a real map entry

        android::base::unique_fd fd{

                bpf_obj_get(BPF_FS_PATH "map_time_in_state_uid_time_in_state_map")};

                bpf_obj_get(BPF_FS_PATH "map_timeInState_uid_time_in_state_map")};

        ASSERT_GE(fd, 0);

        time_key_t k;

        ASSERT_FALSE(getFirstMapKey(fd, &k));
@@ -515,7 +515,7 @@ TEST_F(TimeInStateTest, RemoveUid) { 
        ASSERT_FALSE(writeToMapEntry(fd, &k, vals.data(), BPF_NOEXIST));



        android::base::unique_fd fd2{

                bpf_obj_get(BPF_FS_PATH "map_time_in_state_uid_concurrent_times_map")};

                bpf_obj_get(BPF_FS_PATH "map_timeInState_uid_concurrent_times_map")};

        k.uid = copiedUid;

        k.bucket = 0;

        std::vector<concurrent_val_t> cvals(get_nprocs_conf());