C板卡驱动日志框架优化：头文件中实现无运行时分支的日志宏

我正在为一款大型C板卡驱动设计日志框架，需要记录事件（EVENT）、通知（NOTIFICATION）、**控制消息（CTRL）**等类别。当前的实现代码如下：

static FILE * fptr = NULL; 
void log_to_file(const char *str, int type)
{
    if(fptr == NULL)
    {
        fptr = fopen("file.txt", "a+");
    }

    if (fptr == NULL)
    {
        printf("Error opening file!\n");
    }
    else
    {
        switch (type)
        {
            case 1: //EVENT
                fprintf(fptr, "[%s] [EVENT] %s\n", get_time(), str);
                fflush(fptr);
                break;
            case 2: //NOTIFICATION
                fprintf(fptr, "[%s] [NOTIF] %s\n", get_time(), str);
                fflush(fptr);
                break;
            case 3: //CTRL
                fprintf(fptr, "[%s] [CTRL] %s\n", get_time(), str);
                fflush(fptr);
                break;
            default:
                fprintf(fptr, "[%s] [UNRECOGNIZED] %s\n", get_time(), str);
                fflush(fptr);
                break;
        }
    }
}

我通过以下宏来调用该函数：

#define log_event(str) log_to_file(str, 1)
#define log_notif(str) log_to_file(str, 2)
#define log_ctrl(str) log_to_file(str, 3)

但每次调用都会在运行时解析switch分支，虽然性能影响微小，但我希望进一步优化。我计划将各日志类别拆分为独立函数，通过头文件中的宏调用，在预处理阶段确定日志类型，消除运行时分支。我已有一套输出到stdout的类似框架，但文件指针的打开操作让头文件中实现该方案变得复杂，请问此方案是否可行？有何建议？

你的思路非常合理——通过拆分独立函数+预处理阶段绑定调用，确实可以彻底消除运行时的switch分支开销，同时保持代码的可读性和易用性。针对文件指针的问题，我们可以通过以下几种方式优雅解决：

1. 核心推荐：拆分.c/.h模块，统一管理文件指针 #

不要把文件指针的逻辑放在头文件里，而是拆分到独立的实现文件中，保证全局只有一个文件指针实例，同时拆分出专属日志函数：

第一步：在driver_log.c中实现核心逻辑 #

#include "driver_log.h"
#include <stdio.h>
#include <time.h>

// 文件级私有指针，保证全局唯一
static FILE *fptr = NULL;
static const char *get_time(void) {
    static char time_buf[64];
    time_t now = time(NULL);
    strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S", localtime(&now));
    return time_buf;
}

// 内部辅助函数：确保日志文件已打开，避免重复初始化
static void ensure_log_file_open(void) {
    if (fptr == NULL) {
        fptr = fopen("driver_log.txt", "a+");
        if (fptr == NULL) {
            fprintf(stderr, "[LOG ERROR] Failed to open log file!\n");
        }
    }
}

// 专属事件日志函数
void log_event(const char *str) {
    ensure_log_file_open();
    if (fptr != NULL) {
        fprintf(fptr, "[%s] [EVENT] %s\n", get_time(), str);
        fflush(fptr);
    }
}

// 专属通知日志函数
void log_notif(const char *str) {
    ensure_log_file_open();
    if (fptr != NULL) {
        fprintf(fptr, "[%s] [NOTIF] %s\n", get_time(), str);
        fflush(fptr);
    }
}

// 专属控制消息日志函数
void log_ctrl(const char *str) {
    ensure_log_file_open();
    if (fptr != NULL) {
        fprintf(fptr, "[%s] [CTRL] %s\n", get_time(), str);
        fflush(fptr);
    }
}

第二步：在driver_log.h中声明接口 #

#ifndef DRIVER_LOG_H
#define DRIVER_LOG_H

// 直接暴露专属日志函数，供外部调用
void log_event(const char *str);
void log_notif(const char *str);
void log_ctrl(const char *str);

// 可选：保留原有宏定义，兼容旧代码调用习惯
#define log_event(str) log_event(str)
#define log_notif(str) log_notif(str)
#define log_ctrl(str) log_ctrl(str)

#endif // DRIVER_LOG_H

这种方式下，编译预处理阶段就会把log_event之类的宏直接替换为对应函数调用，完全消除了运行时分支，同时文件指针的初始化逻辑只执行一次，没有重复定义的问题。

2. 进阶方案：单头文件实现（static inline） #

如果希望把所有逻辑放在头文件中（比如作为轻量单文件模块），可以用static inline结合函数内的静态变量实现懒加载：

#ifndef DRIVER_LOG_H
#define DRIVER_LOG_H

#include <stdio.h>
#include <time.h>

static inline const char *get_time(void) {
    static char time_buf[64];
    time_t now = time(NULL);
    strftime(time_buf, sizeof(time_buf), "%Y-%m-%d %H:%M:%S", localtime(&now));
    return time_buf;
}

static inline void log_event(const char *str) {
    // 每个inline函数内的静态变量，在每个编译单元只会初始化一次
    static FILE *fptr = NULL;
    if (fptr == NULL) {
        fptr = fopen("driver_log.txt", "a+");
        if (fptr == NULL) {
            fprintf(stderr, "[LOG ERROR] Failed to open log file!\n");
            return;
        }
    }
    fprintf(fptr, "[%s] [EVENT] %s\n", get_time(), str);
    fflush(fptr);
}

static inline void log_notif(const char *str) {
    static FILE *fptr = NULL;
    if (fptr == NULL) {
        fptr = fopen("driver_log.txt", "a+");
        if (fptr == NULL) {
            fprintf(stderr, "[LOG ERROR] Failed to open log file!\n");
            return;
        }
    }
    fprintf(fptr, "[%s] [NOTIF] %s\n", get_time(), str);
    fflush(fptr);
}

// 同理实现log_ctrl
#endif // DRIVER_LOG_H

注意：这种方式下，每个编译单元会拥有自己的fptr副本，如果驱动是多线程/多进程环境，可能会出现多个文件句柄同时写入同一日志的问题，因此更推荐第一种拆分模块的方案。

3. 额外优化建议 #

• 线程安全：如果驱动运行在多线程环境，需要在ensure_log_file_open()中添加互斥锁（比如pthread_mutex_t），避免并发初始化文件指针的竞争问题。
• 编译期日志开关：可以通过#ifdef DEBUG宏在编译期关闭日志输出，进一步降低性能开销。
• 日志轮转：对于长期运行的驱动，可以在ensure_log_file_open()中增加文件大小检查，当文件达到阈值时自动切换到新日志文件，避免日志文件过大。

内容的提问来源于stack exchange，提问作者Dupontrocks11