tango-maat/src/maat_stat.c

/*
**********************************************************************************************
*	File: maat_stat.c
*   Description:
*	Authors: Liu WenTan <liuwentan@geedgenetworks.com>
*	Date:    2022-10-31
*   Copyright: (c) Since 2022 Geedge Networks, Ltd. All rights reserved.
***********************************************************************************************
*/

#include <assert.h>

#include "maat_utils.h"
#include "maat_stat.h"
#include "fieldstat.h"
#include "alignment.h"
#include "maat_ip.h"
#include "maat_compile.h"
#include "maat_group.h"
#include "maat_plugin.h"
#include "maat_expr.h"

#define MODULE_MAAT_STAT	 module_name_str("maat.stat")

enum MAAT_FS_STATUS {
	STATUS_VERSION = 0,
	STATUS_THRED_NUM,
	STATUS_TABLE_NUM,
	STATUS_PLUGIN_CACHE_NUM,
	STATUS_PLUGIN_ACC_NUM,
    STATUS_CLAUSE_REF_NOT_NUM,
    STATUS_GROUP_REF_EXCL_NUM, //group reference exclude group num
    STATUS_HIT_COMPILE_NUM,
	STATUS_MAAT_STATE_NUM,
    STATUS_MAAT_PER_STATE_MEM,
    STATUS_COMPILE_STATE_NUM,
	STATUS_GARBAGE_QSIZE,
	STATUS_UPDATE_ERR_CNT,
	STATUS_SCAN_ERR_CNT,
	STATUS_STREAM_NUM,
    STATUS_ZOMBIE_STREAM_NUM,
	STATUS_CMD_LINE_NUM
};

enum MAAT_FS_COLUMN {
	COLUMN_RULE_NUM = 0,
	COLUMN_REGEX_NUM,
	COLUMN_SCAN_TIMES, //the times of scan
    COLUMN_HIT_TIMES,  //the times of hit compile
	COLUMN_SCAN_BYTES,
	COLUMN_SCAN_CPU_TIME,    //microseconds
	COLUMN_HIT_ITEM_NUM,
	COLUMN_HIT_PAT_NUM, //hit pattern num(only valid for expr/expr_plus table)
    COLUMN_SCAN_BPS,    //scan bytes per second
    COLUMN_SCAN_TPS,    //scan times per second
    COLUMN_HIT_RATE     //scan hit rate(hit_times/scan_times)
};

const char *common_column_name[] = {"rule", "reg/v6", "scan_times", "hit_times", "scan_bytes", "scan_cpu_time", 
                                    "hit_item_num", "hit_pat_num", "IN_Bps", "IN_Tps", "hit_rate"};

enum field_type common_column_type[] = {
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE,
    FIELD_TYPE_GAUGE
};

#define	MAX_CONJ_NAME_LEN	22
static void maat_fieldstat_register(struct maat_stat *stat)
{
    stat->fs_status_id[STATUS_VERSION] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE,
                                                            "version", NULL, 0);
    stat->fs_status_id[STATUS_THRED_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                              "threads", NULL, 0);
    stat->fs_status_id[STATUS_TABLE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                              "tables", NULL, 0);
    stat->fs_status_id[STATUS_PLUGIN_CACHE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                     "plug_cached", NULL, 0);
    stat->fs_status_id[STATUS_PLUGIN_ACC_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                   "plug_acc", NULL, 0);
    stat->fs_status_id[STATUS_CLAUSE_REF_NOT_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                      "not_clause", NULL, 0);
    stat->fs_status_id[STATUS_GROUP_REF_EXCL_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                      "excl_grp", NULL, 0);
    stat->fs_status_id[STATUS_GARBAGE_QSIZE] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                  "garbage_num", NULL, 0);
    stat->fs_status_id[STATUS_HIT_COMPILE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                    "hit_compile_num", NULL, 0);
    stat->fs_status_id[STATUS_MAAT_STATE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                  "state_num", NULL, 0);
    stat->fs_status_id[STATUS_MAAT_PER_STATE_MEM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                        "per_state_mem(B)", NULL, 0);
    stat->fs_status_id[STATUS_COMPILE_STATE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                     "compile_state_num", NULL, 0);
    stat->fs_status_id[STATUS_STREAM_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                               "stream_num", NULL, 0);
    stat->fs_status_id[STATUS_ZOMBIE_STREAM_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                      "z_stream_num", NULL, 0);
    stat->fs_status_id[STATUS_UPDATE_ERR_CNT] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                   "update_error", NULL, 0);
    stat->fs_status_id[STATUS_SCAN_ERR_CNT] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                 "scan_error", NULL, 0);
    stat->fs_status_id[STATUS_CMD_LINE_NUM] = fieldstat_register(stat->fs_handle, FIELD_TYPE_GAUGE, 
                                                                 "line_cmd/s", NULL, 0);
}

static int maat_fieldstat_table_row_register(struct maat_stat *stat,
                                             struct table_manager *tbl_mgr,
                                             int table_id)
{
    size_t max_table_cnt = table_manager_table_size(tbl_mgr);
    int ret = fieldstat_register_table_row(stat->fs_handle, table_id, "Sum", NULL, 0,
                                           stat->total_stat_id);
    if (ret < 0) {
        log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat_register_table_row Sum failed.");
        return -1;
    }

    ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_BPS],
                                          stat->total_stat_id[COLUMN_SCAN_BYTES],
                                          stat->total_stat_id[COLUMN_SCAN_CPU_TIME], 1000000000);
    if (ret < 0) {
        log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set IN_Bps for Sum failed.");
        return -1;
    }

    ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_TPS],
                                          stat->total_stat_id[COLUMN_SCAN_TIMES],
                                          stat->total_stat_id[COLUMN_SCAN_CPU_TIME], 1000000000);
    if (ret < 0) {
        log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set IN_Tps for Sum failed.");
        return -1;
    }

    ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->total_stat_id[COLUMN_HIT_RATE],
                                          stat->total_stat_id[COLUMN_HIT_TIMES],
                                          stat->total_stat_id[COLUMN_SCAN_TIMES], 1);
    if (ret < 0) {
        log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat set hit_rate for Sum failed.");
        return -1;
    }

    for (size_t i = 0; i < max_table_cnt; i++) {
        void *schema = table_manager_get_schema(tbl_mgr, i);
        if (NULL == schema) {
            continue;
        }

        enum table_type table_type = table_manager_get_table_type(tbl_mgr, i);
        if (table_type == TABLE_TYPE_VIRTUAL) {
            continue;
        }
        
        const char *table_name = table_manager_get_table_name(tbl_mgr, i);
        assert(table_name != NULL);

        ret = fieldstat_register_table_row(stat->fs_handle, table_id, table_name, NULL, 0,
                                           stat->fs_column_id[i]);
        if (ret < 0) {
            log_fatal(stat->logger, MODULE_MAAT_STAT,
                      "fieldstat_register_table_row %s failed.", table_name);
            return -1;
        }

        ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_BPS],
                                              stat->fs_column_id[i][COLUMN_SCAN_BYTES],
                                              stat->fs_column_id[i][COLUMN_SCAN_CPU_TIME], 1000000000);
        if (ret < 0) {
            log_fatal(stat->logger, MODULE_MAAT_STAT,
                      "fieldstat set IN_Bps for %s failed.", table_name);
            return -1;
        }

        ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_TPS],
                                              stat->fs_column_id[i][COLUMN_SCAN_TIMES],
                                              stat->fs_column_id[i][COLUMN_SCAN_CPU_TIME], 1000000000);
        if (ret < 0) {
            log_fatal(stat->logger, MODULE_MAAT_STAT,
                      "fieldstat set IN_Tps for %s failed.", table_name);
            return -1;
        }

        ret = fieldstat_set_metric_ratio_para(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_RATE],
                                              stat->fs_column_id[i][COLUMN_HIT_TIMES],
                                              stat->fs_column_id[i][COLUMN_SCAN_TIMES], 1);
        if (ret < 0) {
            log_fatal(stat->logger, MODULE_MAAT_STAT,
                      "fieldstat set hit_rate for %s failed.", table_name);
            return -1;
        }
    }

    return 0; 
}

struct maat_stat *maat_stat_new(const char *stat_file, size_t max_thread_num,
                                struct log_handle *logger)
{
    struct maat_stat *stat = ALLOC(struct maat_stat, 1);

    size_t str_len = MIN(sizeof(stat->stat_file), strlen(stat_file));
    memcpy(stat->stat_file, stat_file, str_len);

    stat->nr_worker_thread = max_thread_num;
    stat->logger = logger;
    stat->stream_cnt = alignment_int64_array_alloc(max_thread_num);
    stat->thread_call_cnt = alignment_int64_array_alloc(max_thread_num);
    stat->hit_compile_cnt = alignment_int64_array_alloc(max_thread_num);
    stat->maat_state_cnt = alignment_int64_array_alloc(max_thread_num);
    stat->compile_state_cnt = alignment_int64_array_alloc(max_thread_num);
    stat->maat_state_free_cnt = alignment_int64_array_alloc(max_thread_num);
    stat->maat_state_free_bytes = alignment_int64_array_alloc(max_thread_num);

    return stat;
}

void maat_stat_free(struct maat_stat *stat)
{
    if (NULL == stat) {
        return;
    }

    if (stat->stream_cnt != NULL) {
        alignment_int64_array_free(stat->stream_cnt);
        stat->stream_cnt = NULL;
    }

    if (stat->thread_call_cnt != NULL) {
        alignment_int64_array_free(stat->thread_call_cnt);
        stat->thread_call_cnt = NULL;
    }

    if (stat->hit_compile_cnt != NULL) {
        alignment_int64_array_free(stat->hit_compile_cnt);
        stat->hit_compile_cnt = NULL;
    }

    if (stat->maat_state_cnt != NULL) {
        alignment_int64_array_free(stat->maat_state_cnt);
        stat->maat_state_cnt = NULL;
    }

    if (stat->compile_state_cnt != NULL) {
        alignment_int64_array_free(stat->compile_state_cnt);
        stat->compile_state_cnt = NULL;
    }

    if (stat->maat_state_free_cnt != NULL) {
        alignment_int64_array_free(stat->maat_state_free_cnt);
        stat->maat_state_free_cnt = NULL;
    }

    if (stat->maat_state_free_bytes != NULL) {
        alignment_int64_array_free(stat->maat_state_free_bytes);
        stat->maat_state_free_bytes = NULL;
    }

    if (stat->fs_handle != NULL) {
        fieldstat_instance_free(stat->fs_handle);
        stat->fs_handle = NULL;
    }

    FREE(stat);
}

int maat_stat_init(struct maat_stat *stat, struct table_manager *tbl_mgr, 
                    struct maat_garbage_bin *garbage_bin)
{
    if (NULL == stat || NULL == tbl_mgr || NULL == garbage_bin) {
        return -1;
    }

    const char *instance_name = "maat_stat";
	stat->fs_handle = fieldstat_instance_new(instance_name);
    if (NULL == stat->fs_handle) {
        log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat_instance_new failed.");
        return -1;
    }

    int ret = fieldstat_set_local_output(stat->fs_handle, stat->stat_file, "default");
    if (ret < 0) {
        log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat_set_local_output failed.");
        return -1;
    }

    ret = fieldstat_disable_background_thread(stat->fs_handle);
    if (ret < 0) {
        log_fatal(stat->logger, MODULE_MAAT_STAT,
                  "fieldstat_disable_background_thread failed.");
        return -1;
    }

    maat_fieldstat_register(stat);

    stat->ref_tbl_mgr = tbl_mgr;
    stat->ref_garbage_bin = garbage_bin;
    size_t n_column = sizeof(common_column_name) / sizeof(common_column_name[0]);
    int fs_table_id = fieldstat_register_table(stat->fs_handle, instance_name, 
                                               common_column_name, common_column_type, 
                                               n_column);
    if (fs_table_id < 0) {
        log_fatal(stat->logger, MODULE_MAAT_STAT, "fieldstat_register_table failed.");
        return -1;
    }

    ret = maat_fieldstat_table_row_register(stat, tbl_mgr, fs_table_id);
    if (ret < 0) {
        return -1;
    }

    fieldstat_instance_start(stat->fs_handle);

    return 0;
}

static void maat_fieldstat_table_row_output(struct maat_stat *stat, int perf_on)
{
    long long plugin_cache_num = 0, plugin_rule_num = 0;
    long long total_rule_num = 0, total_input_bytes = 0, total_update_err = 0;
    long long total_scan_times = 0, total_scan_cpu_time = 0, total_regex_num = 0;
    long long total_ipv6_num = 0, total_hit_item_num = 0, total_hit_pattern_num = 0;
    long long g2c_not_clause_num = 0, g2g_excl_rule_num = 0;
    size_t max_table_count = table_manager_table_size(stat->ref_tbl_mgr);

    for (size_t i = 0; i < max_table_count; i++) {
        long long regex_rule_num = 0;
        long long ipv6_rule_num = 0;
        void *schema = table_manager_get_schema(stat->ref_tbl_mgr, i);
        if (NULL == schema) {
            continue;
        }

        enum table_type table_type = table_manager_get_table_type(stat->ref_tbl_mgr, i);
        assert(table_type != TABLE_TYPE_INVALID);

        void *runtime = table_manager_get_runtime(stat->ref_tbl_mgr, i);

        switch (table_type) {
            case TABLE_TYPE_PLUGIN:
                plugin_cache_num += plugin_runtime_cached_row_count(runtime);
                plugin_rule_num += plugin_runtime_rule_count(runtime);
                break;
            case TABLE_TYPE_GROUP2COMPILE:
                g2c_not_clause_num += group2compile_runtime_not_clause_count(runtime);
                break;
            case TABLE_TYPE_GROUP2GROUP:
                g2g_excl_rule_num += group2group_runtime_exclude_rule_count(runtime);
                break;
            case TABLE_TYPE_EXPR:
            case TABLE_TYPE_EXPR_PLUS:
                regex_rule_num = expr_runtime_regex_rule_count(runtime);
                break;
            case TABLE_TYPE_IP_PLUS:
                ipv6_rule_num = ip_runtime_ipv6_rule_count(runtime);
                break;
            default:
                break;
        }

        if (table_type == TABLE_TYPE_VIRTUAL) {
            continue;
        }

        total_regex_num += regex_rule_num;
        total_ipv6_num += ipv6_rule_num;

        long long rule_num = table_manager_runtime_rule_count(stat->ref_tbl_mgr, i);
        fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_RULE_NUM], rule_num);
        total_rule_num += rule_num;

        long long scan_times = table_manager_runtime_scan_times(stat->ref_tbl_mgr, i);
        fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_TIMES], scan_times);
        total_scan_times += scan_times;

        if (table_type == TABLE_TYPE_PLUGIN || table_type == TABLE_TYPE_IP_PLUGIN ||
            table_type == TABLE_TYPE_IPPORT_PLUGIN || table_type == TABLE_TYPE_BOOL_PLUGIN ||
            table_type == TABLE_TYPE_FQDN_PLUGIN) {
            continue;
        }

        if (table_type == TABLE_TYPE_EXPR || table_type == TABLE_TYPE_EXPR_PLUS) {
            fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_REGEX_NUM],
                                regex_rule_num);
            long long input_bytes = expr_runtime_scan_bytes(runtime);
            fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_BYTES],
                                input_bytes);
            total_input_bytes += input_bytes;

            long long hit_pattern_num = expr_runtime_hit_pattern_num(runtime);
            fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_PAT_NUM],
                                hit_pattern_num);
            total_hit_pattern_num += hit_pattern_num;
        }

        if (table_type == TABLE_TYPE_IP_PLUS) {
            fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_REGEX_NUM],
                                ipv6_rule_num);
        }

        if (1 == perf_on) {
            long long scan_cpu_time = table_manager_runtime_scan_cpu_time(stat->ref_tbl_mgr, i);
            fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_SCAN_CPU_TIME],
                                scan_cpu_time);
            total_scan_cpu_time += scan_cpu_time;
        }

        long long hit_item_num = table_manager_runtime_hit_item_num(stat->ref_tbl_mgr, i);
        fieldstat_value_set(stat->fs_handle, stat->fs_column_id[i][COLUMN_HIT_ITEM_NUM], hit_item_num);
        total_hit_item_num += hit_item_num;

        total_update_err += table_manager_runtime_update_err_count(stat->ref_tbl_mgr, i);
    }

    fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_RULE_NUM],
                        total_rule_num);
    fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_REGEX_NUM],
                        total_regex_num);
    fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_TIMES],
                        total_scan_times);
    fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_HIT_ITEM_NUM],
                        total_hit_item_num);
    fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_HIT_PAT_NUM],
                        total_hit_pattern_num);
    fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_BYTES],
                        total_input_bytes);

    if (1 == perf_on) {
        fieldstat_value_set(stat->fs_handle, stat->total_stat_id[COLUMN_SCAN_CPU_TIME],
                            total_scan_cpu_time);
    }

    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_UPDATE_ERR_CNT],
                        total_update_err);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_SCAN_ERR_CNT],
                        stat->scan_err_cnt);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_PLUGIN_CACHE_NUM],
                        plugin_cache_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_PLUGIN_ACC_NUM],
                        plugin_rule_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_CLAUSE_REF_NOT_NUM],
                        g2c_not_clause_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_GROUP_REF_EXCL_NUM],
                        g2g_excl_rule_num);
}

void maat_stat_output(struct maat_stat *stat, long long maat_version, int perf_on)
{
    if (NULL == stat) {
        return;
    }

    long long active_thread_num = alignment_int64_array_cnt(stat->thread_call_cnt, 
                                                            stat->nr_worker_thread);
    long long stream_num = alignment_int64_array_sum(stat->stream_cnt,
                                                     stat->nr_worker_thread);
    long long hit_compile_num = alignment_int64_array_sum(stat->hit_compile_cnt,
                                                          stat->nr_worker_thread);
    long long maat_state_num = alignment_int64_array_sum(stat->maat_state_cnt,
                                                         stat->nr_worker_thread);
    long long compile_state_num = alignment_int64_array_sum(stat->compile_state_cnt,
                                                            stat->nr_worker_thread);
    long long maat_state_free_num = alignment_int64_array_sum(stat->maat_state_free_cnt,
                                                              stat->nr_worker_thread);
    long long maat_state_free_bytes = alignment_int64_array_sum(stat->maat_state_free_bytes,
                                                                stat->nr_worker_thread);
    
    size_t table_num = table_manager_table_num(stat->ref_tbl_mgr);
    size_t garbage_q_len = maat_garbage_bin_get_size(stat->ref_garbage_bin);

    long long per_state_mem = 0;
    if (maat_state_free_num != 0) {
        per_state_mem = maat_state_free_bytes / maat_state_free_num;
    }
    
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_VERSION],
                        maat_version);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_THRED_NUM],
                        active_thread_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_TABLE_NUM],
                        table_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_HIT_COMPILE_NUM],
                        hit_compile_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_MAAT_STATE_NUM],
                        maat_state_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_MAAT_PER_STATE_MEM],
                        per_state_mem);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_COMPILE_STATE_NUM],
                        compile_state_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_CMD_LINE_NUM],
                        stat->line_cmd_acc_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_GARBAGE_QSIZE],
                        garbage_q_len);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_STREAM_NUM],
                        stream_num);
    fieldstat_value_set(stat->fs_handle, stat->fs_status_id[STATUS_ZOMBIE_STREAM_NUM],
                        stat->zombie_rs_stream);
    maat_fieldstat_table_row_output(stat, perf_on);

	fieldstat_passive_output(stat->fs_handle);
}