进程间同步(Process Synchronization)-2 通过semaphore方式来实现进程间同步的例子

 

出处：仮想デバイスドライバを利用したプロセス間通信について http://cheesy.dip.jp/tutorialog/archives/6

仮想デバイスドライバを利用したプロセス間通信について説明します。といってもよくわからないと思うので、ちゃんと説明します。
Unixでプロセス間通信というと、ソケットを使ったもの、パイプを使ったもの、共有メモリを使ったもの等がありますが、それぞれ長所・短所があると思います。
ものすごく簡単に言うと、
ソケットでは、
複数マシン間での通信が可能
通信処理のオーバーヘッドが大きい(コネクション開始・終了処理も含め)
パイプでは、
ソケットより通信処理のオーバーヘッドが少ない
親子関係のプロセスに限定される
共有メモリでは、
シンプルで高速
書き込み・読み取りの同期をとるのが難しい
等が挙げられると思います。

共有メモリがシンプルかつ高速ですばらしいのですが、アプリケーションレベルで同期をとるのが難しいという問題があります。そこで、ここでは、
共有メモリによるプロセス間通信における同期機構を、仮想デバイスドライバを使って行う手法を説明しようと思います。
開発環境は、FedoraCore4(2.6.11-1.1369_FC4)、gcc 4.0.0、GNU make 3.80です。
Linuxのデバイスドライバについては、私も詳しくないですが、以下のページが参考になると思いますので、書いたことのない方は一度見てみてください。
The Linux Kernel Module Programming Guide
Linux Kernel Module programming(Kernel 2.4)
概要
同期の仕組みですが、デバイスドライバにpoll関数を実装し、そこで読み込みと書き込みの待ち列を設定します。書き込み(write)後に読み込み可能
になったら読み込みの待ち列に対して、wake_upを実行します。ユーザ側のプロセスでは、デバイスドライバをselect(2)で待ち(poll関数が呼び出
される)、読み込み可能になり次第、カーネルから起こされ読み込み処理を実行できるようになります。 書き込みも同じ原理で動きます。しかし、読み込
みと書き込みは同時には実行できません。(当たり前ですが。)
実装
次に、実際のソースについて解説します。デバイスドライバといっても、本物のデバイスを操作するわけではなく、同期を取るだけで実際の通信データも
扱わないので非常に単純です。ソースはこちらです。(sync.c)
#include <linux/kernel.h>
#include <linux/module.h> 
#include <linux/sched.h>
#include <linux/wait.h>
#include <linux/poll.h>
#include <linux/fs.h>
#include <linux/errno.h>
#include <asm/semaphore.h>
#include <asm/uaccess.h>

MODULE_AUTHOR("Hiroyuki");
MODULE_DESCRIPTION("Pseudo device driver for synchronizing processes.");
MODULE_LICENSE( "GPL" );

static int syncopen(struct inode* inode, struct file* filp);
static int syncclose(struct inode* inode, struct file* filp);
static ssize_t syncread(struct file* filp, char* buf, size_t count, loff_t* pos);
static ssize_t syncwrite(struct file* filp, const char* buf, size_t count, loff_t* pos);
static unsigned int syncpoll(struct file* filp, poll_table* wait);

#define DEV_NAME "sync"             // デバイスの名前
#define SYNC_MAJOR 100              // デバイスのメジャー番号

static int is_readable = 0;         // デバイスが読み取り可能かのフラグ
static struct semaphore sync_sem;   // セマフォ
static wait_queue_head_t write_q;   // 書き込みのウェイトキュー
static wait_queue_head_t read_q;    // 読み込みのウェイトキュー

static struct file_operations sync_fops = 
{
	owner   : THIS_MODULE,
	read    : syncread,
	write   : syncwrite,
	poll    : syncpoll,
	open    : syncopen,
	release : syncclose,
};

int
init_module(void)
{
	if (register_chrdev(SYNC_MAJOR, DEV_NAME, &sync_fops)) {
		printk(KERN_INFO "register_chrdev failed/n");
		return -EBUSY;
	}

	sema_init(&sync_sem, 1);
	init_waitqueue_head(&write_q);
	init_waitqueue_head(&read_q);

	return 0;
}

void 
cleanup_module(void)
{
	if (unregister_chrdev(SYNC_MAJOR, DEV_NAME) ) {
		printk(KERN_INFO "unregister_chrdev failed/n");
	}
}

static int 
syncopen(struct inode* inode, struct file* filp)
{
	return 0;
}

static int 
syncclose(struct inode* inode, struct file* filp)
{
	return 0;
}

/*read時に呼び出される関数です
 *セマフォを取得し、読み込み可能フラグ(is_readable)を0(不可)に設定しています
 *(今回はセマフォは特に必要ありません)
 *その後、書き込みの待ち列に対して、wake_up_interruptibleを実行し、書き込み可能状態にしています*/
static ssize_t 
syncread(struct file* filp, char* buf, size_t count, loff_t* pos)
{
	if (down_interruptible(&sync_sem)) {
		printk(KERN_INFO "down_interruptible for read failed/n");
		return -ERESTARTSYS;
	}

    is_readable = 0;

	up(&sync_sem);
    printk(KERN_INFO "wake_up write_q/n");
	wake_up_interruptible(&write_q);

	return 0;
}

/*write時に呼び出される関数です
 *今度は読み込み可能フラグ(is_readable)を1(可)に設定しています
 *readと同様に、wake_up_interruptibleを読み込みの待ち列に対して実行し、読み込み可能状態にしています*/
static ssize_t 
syncwrite(struct file* filp, const char* buf, size_t count, loff_t* pos)
{
	if (down_interruptible(&sync_sem)) {
		printk(KERN_INFO "down_interruptible for write failed/n");
		return -ERESTARTSYS;
	}

    is_readable = 1;

	up(&sync_sem);
    printk(KERN_INFO "wake_up read_q/n");
	wake_up_interruptible(&read_q);

	return 0;
}

/*ユーザプロセスからのselect(2)や、wake_up_interruptible後に呼び出される関数です
 *読み込み(read_q)と書き込み(write_q)の待ち列をセットし
 *読み込み可能なら(POLLIN | POLLRDNORM)、書き込み可能なら(POLLOUT | POLLWRNORM)を返します
 *selectしているユーザプロセスはこの戻り値によって、読み込可能、書き込み可能を判断しています*/
static unsigned int 
syncpoll(struct file* filp, poll_table* wait)
{
	unsigned int retmask = 0;

    printk(KERN_INFO "poll_wait called/n");
	poll_wait(filp, &read_q,  wait);
	poll_wait(filp, &write_q, wait);
    printk(KERN_INFO "poll_done called/n");

	if (is_readable) {
		retmask |= (POLLIN | POLLRDNORM);
	}
	if (!is_readable) {
		retmask |= (POLLOUT | POLLWRNORM);
	}

	return retmask;
} 
 
コンパイル
 
ソースのコンパイルは以下のMakefileを使います
obj-m := sync.o

all:
    make -C /lib/modules/$(shell uname -r)/build M=`pwd` V=1 modules

clean:
    make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean 
 
 

  
  
% make

  
  
make -C /lib/modules/2.6.11-1.1369_FC4/build M=`pwd` V=1 modules
...
モジュールをカーネルに組み込む
コンパイルがうまくいくと、モジュールファイルsynk.koができていると思います。後は組み込んで、デバイスファイルを作るだけです。
 
% sudo /sbin/insmod sync.ko
% sudo mknod /dev/sync c 100 0
以上で、プロセス間同期用のデバイスファイルの作成と組み込みは終わりです。	
動作テスト
次は実際に、書き込み、読み込みの2プロセス間でプロセス間通信をさせてみます。
まずは書き込みのプログラムです。(map_write.c)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>

#define BUFSIZE 4096

int
main(void)
{
    fd_set wfds;
    int fd, dev;
    int pagesize, mapsize;
    char *map;
    char *message = "Hello, are you getting my request ?";

    pagesize = sysconf(_SC_PAGE_SIZE);
    mapsize = ((BUFSIZE-1)/pagesize+1) * pagesize;
        
    if((fd = open("./map.shm", O_RDWR|O_CREAT, 0666)) == -1) {
        perror("open map");
        exit(-1);
    }
    if ((dev = open("/dev/sync", O_RDWR)) == -1) {
        perror("open sync");
        exit(-1);
    }
    if (ftruncate(fd, mapsize) == -1) {
        perror("ftruncate");
        exit(-1);
    }
    map = (char *) mmap(0, mapsize, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
    if (map == MAP_FAILED) {
        perror("mmap");
        exit(-1);
    } 

    FD_ZERO(&wfds);
    FD_SET(dev, &wfds);
    printf("selecting .../n");
    if (select(dev+1, NULL, &wfds, NULL, NULL) == -1) {
       perror("select"); 
       exit(-1);
    }
    printf("wait released./n");

    if (FD_ISSET(dev, &wfds)) {
        strncpy(map, message, mapsize);
        if (write(dev, NULL, 1) == -1) {
            perror("write");
            exit(-1); 
        }
    }

    if (munmap(map, mapsize) == -1) {
        perror("munmap");
        exit(-1);
    }
    close(fd);

    return 0;
}
 
次に読み込み側です。(map_read.c)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/types.h>
#include <unistd.h>
#include <sys/mman.h>

#define BUFSIZE 4096

int main(int argc, char *argv[])
{
    fd_set rfds;
    int fd, dev;
    int pagesize, mapsize;
    char buf[256];
    char *map;

    pagesize = sysconf(_SC_PAGE_SIZE);
    mapsize = ((BUFSIZE-1)/pagesize+1) * pagesize;

    if ((fd = open("./map.shm", O_RDONLY)) == -1) {
        perror("open");
        exit(-1);
    }
    if ((dev = open("/dev/sync", O_RDONLY)) == -1) {
        perror("open");
        exit(-1);
    }

    map = (char *) mmap(0, mapsize, PROT_READ,  MAP_SHARED, fd, 0);
    if (map == MAP_FAILED) {
        perror("mmap");
        return -1;
    }

    FD_ZERO(&rfds);
    FD_SET(dev, &rfds);

    printf("selecting .../n");
    if (select(dev+1, &rfds, NULL, NULL, NULL) == -1) {
        perror("select");
    }

    if (FD_ISSET(dev, &rfds)) {
        printf("get data from mapped area [%s]/n", map);
        read(dev, buf, 256);
    }

    if (munmap(map, mapsize) == -1) {
        perror("munmap");
    }
    close(dev);
    close(fd);

    return 0;
}
 
コンパイルし、実際に動かしてみます。
 
% gcc map_write.c -o map_write
% gcc map_read.c -o map_read
読み込みプロセスを実行すると、書き込みがあるまで待ちます。
% ./map_read
selecting ...
書き込みを実行すると、書き込み可能なため待つことなく、書き込みを実行し、その直後に
読み込み可能となり、共有メモリからのデータを受け取ることができます。
% sudo ./map_write
selecting ...
wait released.
% ./map_read
selecting ...
get data from mapped area [Hello, are you getting my request ?]
まとめ
今回は、共有メモリにおけるプロセス間通信の欠点を補うような同期機構を、仮想デバイスファイルを利用することによって実現しました。
この機構を利用すれば、同一マシン間での高速なプロセス間のデータ受け渡しが可能になるので、パフォーマンスが重要になってくるよう
なアプリケーションで役に立つかもしれません。
知识点补充
sem_init - initialise an unnamed semaphore
Synopsis
#include <semaphore.h>
int sem_init(sem_t *sem, int pshared, unsigned int value);
Description

sem_init() initialises the unnamed semaphore at the address pointed to by sem. 
The value argument specifies the initial value for the semaphore.The pshared argument 
indicates whether this semaphore is to be shared between the threads of a process, 
or between processes.