MPI多进程独立写入共享日志文件的互斥同步方案问询

当然可以实现，下面是几种适配你场景的可行方案：

1. 基于MPI通信的集中式锁管理 #

指定一个固定进程（比如rank 0）作为锁服务器，其他进程写入日志前先向它请求锁，获得许可后执行写入，完成后释放锁。

#include <mpi.h>
#include <stdio.h>

#define LOCK_REQUEST 1
#define LOCK_GRANT 2
#define LOCK_RELEASE 3

void log_message(int rank, const char* msg) {
    // 向rank 0请求锁
    MPI_Send(NULL, 0, MPI_INT, 0, LOCK_REQUEST, MPI_COMM_WORLD);
    
    // 等待锁许可
    MPI_Recv(NULL, 0, MPI_INT, 0, LOCK_GRANT, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
    
    // 写入日志
    FILE* fp = fopen("shared.log", "a");
    if (fp) {
        fprintf(fp, "[Rank %d] %s\n", rank, msg);
        fclose(fp);
    }
    
    // 释放锁
    MPI_Send(NULL, 0, MPI_INT, 0, LOCK_RELEASE, MPI_COMM_WORLD);
}

// 锁服务器进程（rank 0）的处理逻辑
void lock_server() {
    int lock_held = 0;
    MPI_Status status;
    while (1) {
        MPI_Recv(NULL, 0, MPI_INT, MPI_ANY_SOURCE, MPI_ANY_TAG, MPI_COMM_WORLD, &status);
        if (status.MPI_TAG == LOCK_REQUEST) {
            // 等待锁释放后授予请求
            while (lock_held) {
                MPI_Recv(NULL, 0, MPI_INT, MPI_ANY_SOURCE, LOCK_RELEASE, MPI_COMM_WORLD, &status);
                lock_held = 0;
            }
            MPI_Send(NULL, 0, MPI_INT, status.MPI_SOURCE, LOCK_GRANT, MPI_COMM_WORLD);
            lock_held = 1;
        } else if (status.MPI_TAG == LOCK_RELEASE) {
            lock_held = 0;
        }
    }
}

int main(int argc, char** argv) {
    int rank, size;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    MPI_Comm_size(MPI_COMM_WORLD, &size);
    
    if (rank == 0) {
        lock_server();
    } else {
        // 模拟日志写入
        log_message(rank, "This is a test log message");
    }
    
    MPI_Finalize();
    return 0;
}

优缺点：实现简单，不依赖文件系统特性，但锁服务器会成为单点瓶颈，适合日志写入频率不高的场景。

2. 使用MPI-IO的文件锁机制 #

MPI标准提供了MPI_File_lock和MPI_File_unlock函数，专门用于共享文件的互斥写入控制，跨平台兼容性更好。

#include <mpi.h>
#include <stdio.h>

void log_message(int rank, const char* msg) {
    MPI_File fh;
    MPI_Status status;
    
    // 共享模式打开日志文件
    MPI_File_open(MPI_COMM_WORLD, "shared.log", MPI_MODE_CREATE | MPI_MODE_WRONLY | MPI_MODE_APPEND, MPI_INFO_NULL, &fh);
    
    // 请求排他锁
    MPI_File_lock(fh, MPI_LOCK_EXCLUSIVE, 0, MPI_OFFSET_KIND, MPI_INFO_NULL);
    
    // 准备并写入日志内容
    char buffer[256];
    int len = snprintf(buffer, sizeof(buffer), "[Rank %d] %s\n", rank, msg);
    MPI_File_write(fh, buffer, len, MPI_CHAR, &status);
    
    // 释放锁并关闭文件
    MPI_File_unlock(fh);
    MPI_File_close(&fh);
}

int main(int argc, char** argv) {
    int rank;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    
    // 模拟日志写入
    log_message(rank, "Test log via MPI-IO lock");
    
    MPI_Finalize();
    return 0;
}

优缺点：符合MPI标准，无需额外锁服务器，适配多数分布式文件系统；需注意MPI_File_open的模式参数设置，确保进程间共享打开文件。

3. 利用文件系统级互斥锁（POSIX flock/fcntl） #

如果运行环境支持POSIX标准，可以直接用文件系统的互斥锁，对日志文件加锁后写入。

#include <mpi.h>
#include <stdio.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/file.h>

void log_message(int rank, const char* msg) {
    int fd = open("shared.log", O_WRONLY | O_CREAT | O_APPEND, 0644);
    if (fd == -1) {
        perror("Failed to open log file");
        return;
    }
    
    // 阻塞获取排他锁
    if (flock(fd, LOCK_EX) == -1) {
        perror("Failed to lock log file");
        close(fd);
        return;
    }
    
    // 写入日志
    char buffer[256];
    int len = snprintf(buffer, sizeof(buffer), "[Rank %d] %s\n", rank, msg);
    write(fd, buffer, len);
    
    // 释放锁并关闭文件
    flock(fd, LOCK_UN);
    close(fd);
}

int main(int argc, char** argv) {
    int rank;
    MPI_Init(&argc, &argv);
    MPI_Comm_rank(MPI_COMM_WORLD, &rank);
    
    log_message(rank, "Test log via POSIX flock");
    
    MPI_Finalize();
    return 0;
}

优缺点：实现简单，无需MPI额外通信，但仅在单节点或支持分布式锁的集群文件系统（如Lustre、GPFS）上有效，跨节点场景可能失效。

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