test-malloc-stats-print.c

/*
 * Copyright (C) 2022 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#include <regex.h>
#include "test-malloc-info-stats-print.h"

#define THREAD_DATA_REGEX_LEN (MAX_TID_LEN + 43)
#define REGEX_NMATCH 1

static void stderr_stats_cb(void)
{
    malloc_stats_print(print_to_file, stderr, "");
}

static int parse_amount(const char **s, long long *destination)
{
    char *end_ptr = NULL;
    long long result = strtoll(*s, &end_ptr, 10);
    if (end_ptr == *s) {
        return 0;
    }
    *s = end_ptr;
    if ((!isspace(*end_ptr) && *end_ptr != '\n' && *end_ptr != '\0') || result < 0) {
        return 0;
    }
    *destination = result;
    return 1;
}

static const char * find_thread_in_output(const char *output, const char *thread_id) 
{
    char thread_data_regex_s[THREAD_DATA_REGEX_LEN + 1];
    snprintf(thread_data_regex_s, THREAD_DATA_REGEX_LEN, "^%s([[:space:]]+[[:digit:]]+){3}[[:space:]]*$", thread_id);
    regex_t thread_data_regex;
    if (regcomp(&thread_data_regex, thread_data_regex_s, REG_EXTENDED | REG_NEWLINE) != 0) {
        t_error("Failed to compile regex %s", thread_data_regex_s);
        return NULL;
    }

    regmatch_t pmatch[REGEX_NMATCH];
    int match_result = regexec(&thread_data_regex, output, REGEX_NMATCH, pmatch, 0);
    regfree(&thread_data_regex);
    if (match_result != 0) {
        return NULL;
    }
    return output + pmatch[0].rm_so;
}

static int populate_thread_stats(const char *output, const char *thread_id, malloc_thread_stats_t *stats)
{
    const char *thread_data_start = find_thread_in_output(output, thread_id);
    if (thread_data_start == NULL) {
        t_error("Failed to find thread id %s in output", thread_id);
        return 0;
    }

    thread_data_start += strlen(thread_id);
    int result = 1;
    result &= parse_amount(&thread_data_start, &stats->total_allocated_memory);
    result &= parse_amount(&thread_data_start, &stats->total_mmapped_memory);
    result &= parse_amount(&thread_data_start, &stats->mmapped_regions);

    return result;
}

static int populate_total_free_heap_space(const char *output, long long *total_free_heap_space)
{
    const char *free_heap_space_start = strstr(output, "total free heap space:");
    if (free_heap_space_start == NULL) {
        return 0;
    }
    free_heap_space_start += strlen("total free heap space:");
    return parse_amount(&free_heap_space_start, total_free_heap_space);
}

static int is_thread_in_output(const char *output, const char *thread_id) 
{
    return find_thread_in_output(output, thread_id) != NULL;
}