세마포어(semaphore)와 공유 메모리(shared memory) 함수

 PHP_공유_메모리와_세마포어_활용.pdf

 

세마포어(semaphore)와 공유 메모리(shared memory) 함수

이 모듈은 System V 세마포어가 사용하는 세마포어 함수를 포함한다. 세마포어는 현재 머신에 자원을 한정적으로 접근하는데 사용되거나 프로세스가 일제히 자원을 사용하는 개수를 제한하는데 사용된다.

이 모듈은 또한 System V의 공유 메모리를 사용하기 위한 공유 메모리 함수도 포함한다. 공유 메모리는 전역 변수에 접근하는데 사용된다. 각기 다른 httpd-daemon과 다른 프로그램(Perl, C와 같은) 조차도 전역 데이터 교환을 지원하여 이 데이터를 접근할 수 있다. 주의할 점은, 공유 메모리는 동시 접근에는 안전하지 않다는 것이다. 동기화를 위해서는 세마포어를 사용하면 된다.

Unix OS에 의한 공유 메모리의 제한
SHMMAX 공유 메모리의 최대값, 보통 131072 바이트임.
SHMMIN 공유 메모리의 최소값, 보통 1바이트임.
SHMMNI 시스템 상의 공유 메모리 세그먼트의 최대 합계, 보통 100임.
SHMSEG 프로세서당 공유 메모리 세그먼트의 최대 합계, 보통 6임.

Note: 이 함수는 윈도우즈 시스템에서 동작하지 않는다.

Table of Contents

  • ftok — Convert a pathname and a project identifier to a System V IPC key
  • msg_get_queue — Create or attach to a message queue
  • msg_receive — Receive a message from a message queue
  • msg_remove_queue — Destroy a message queue
  • msg_send — Send a message to a message queue
  • msg_set_queue — Set information in the message queue data structure
  • msg_stat_queue — Returns information from the message queue data structure
  • sem_acquire — 세마포어를 획득
  • sem_get — 세마포어 id를 얻음
  • sem_release — 세마포어 릴리즈
  • sem_remove — Remove a semaphore
  • shm_attach — 공유 메모리 세그먼트를 열거나 생성
  • shm_detach — 공유 메모리 세그먼트 접속을 종료
  • shm_get_var — 공유 메모리로부터 변수를 반환
  • shm_put_var — 공유 메모리 변수를 삽입하거나 경신
  • shm_remove_var — 공유 메모리로부터 변수를 제거
  • shm_remove — Unix 시스템에서 공유 메모리를 제거



add a note add a note User Contributed Notes
세마포어
alexh at southwestmicrowave dot com
20-Feb-2008 02:24
I've had a devil of a time interfacing with non-PHP declared shared memory.  DO NOT do this unless you read the php-X.X.X/ext/sysvshm/ code directly.  Non-PHP programs need to use exactly the same "shared memory" struct as PHP uses, otherwise this "system V standard" call doesn't work.

Here are the specific deviations from the System-V C-calls:

<?
$shmkey
= ftok($shmkey_path, $shmkey_proj_id);
?>

In C the $shmkey_proj_id is an int, but in PHP it's a char* to a single char.  This means that your C program is restricted to using 0-255 (in PHP chr(0) through chr(255)) for project ID's, if it used anything else then you have to re-write your C-routine.

<?
$var
= shm_get_var($shm_id, 0);
$fail = shm_put_var($shm_id, 0, $var1 )
?>

There are no such things as a system V calls like this at all.  In system V you simply have a pointer to the beginning of your shared memory segment after attaching, so as long as you offset to the right spot you get what you want.  In PHP, shared memory is ONLY cast as a struct, and the "data" is serialized as a string in the "mem" portion of the struct:

<? //C code
typedef struct {
       
long key;
       
long length;
       
long next;
       
char mem;
}
sysvshm_chunk;
?>

If your C program didn't use this struct you need to re-write it to use this struct and write everything as a string. 

This is rather absurd, as the purpose of shared memory is to communicate quickly with other programs resident in memory.  But it is what it is.
mr dot smaon at gmail dot com
26-Jan-2007 02:08
Here is a simple Mutex class implementation, using semaphore on Linux and flock on windows.
Filename is optionnal, but you can provide it anyway. This way the file will be created on windows, not on linux as it is not needed.
It's fast written and certainly lacks error checking code.

<?php

   
class Mutex
   
{
       
private $id;
       
private $sem_id;
       
private $is_acquired = false;
       
private $is_windows = false;
       
private $filename = '';
       
private $filepointer;

        function
__construct()
        {
            if(
substr(PHP_OS, 0, 3) == 'WIN')
               
$this->is_windows = true;
        }

       
public function init($id, $filename = '')
        {
           
$this->id = $id;

            if(
$this->is_windows)
            {
                if(empty(
$filename)){
                    print
"no filename specified";
                    return
false;
                }
                else
                   
$this->filename = $filename;
            }
            else
            {
                if(!(
$this->sem_id = sem_get($this->id, 1))){
                    print
"Error getting semaphore";
                    return
false;
                }
            }

            return
true;
        }

       
public function acquire()
        {
            if(
$this->is_windows)
            {
                if((
$this->filepointer = @fopen($this->filename, "w+")) == false)
                {
                    print
"error opening mutex file<br>";
                    return
false;
                }
               
                if(
flock($this->filepointer, LOCK_EX) == false)
                {
                    print
"error locking mutex file<br>";
                    return
false;
                }
            }
            else
            {
                if (!
sem_acquire($this->sem_id)){
                    print
"error acquiring semaphore";
                    return
false;
                }
            }

           
$this->is_acquired = true;
            return
true;
        }

       
public function release()
        {
            if(!
$this->is_acquired)
                return
true;

            if(
$this->is_windows)
            {
                if(
flock($this->filepointer, LOCK_UN) == false)
                {
                    print
"error unlocking mutex file<br>";
                    return
false;
                }

               
fclose($this->filepointer);
            }
            else
            {
                if (!
sem_release($this->sem_id)){
                    print
"error releasing semaphore";
                    return
false;
                }
            }

           
$this->is_acquired = false;
            return
true;
        }

       
public function getId()
        {
            return
$this->sem_id;
        }
    }

?>

Example use:

<?php

    $mutex
= new Mutex();
   
$mutex->init(1, "mutex_file.txt");
   
$mutex->acquire();

   
//Whatever you want single-threaded here...
   
$mutex->release();

?>
hekkwan at gmail dot com
14-Nov-2006 11:15
I have been trying to get a php console script and a C application to use a common semaphore for a while. I just got it working, so I thought Id paste the code here incase anyone needs to do this, however, this is not the place for long code examples

I used c code from the php implementation to set up the semaphore set and then mimic the way the php interpreter implements a mutext type locking scheme, using a common semop call.

One has to do the process in the same way as its done in the php implementation, otherwise you run the risk of the php interpreter resetting the semaphore set for you.

The basic idea is.
1) sem_get - use a three semaphore set
1.1) increment the first sem
1.2) check the usage count (sem 3), if only one, set the max_attach using sem 2 for mutex behaviour to sem 3
2) decrement sem 1
3) for locking / unlocking use the first semaphore, but always call the above from your c-code.

If you want a copy of my code, email me and I'll happily send it to you !
chrissavery at removeme dot gmail dot com
03-Jun-2006 05:18
I was confused by two things that caused strange behaviour in my use of semaphores with php scripts running under apache.

Often enough page requests will end up being filled by the same process as other simultaneous requests. So semaphores will block when you may not have expected.

Also note that sem_remove() will remove it for all processes, not just the calling one. So you have to be sure that the last process running removes the semaphore and none before. I thought there was some failures occurring when my child processes were dropping out with errors.

So you can't just use get, acquire, release, remove in one script that will be hit by a web user. (1) They may end up in the same process and will wait on the other, and (2) the first one to finish will destroy the semaphore for others.

I left out the remove call, and it works ok, but I still wonder if the semaphore is removed by php when the last script that did a get finishes? Also creating a child process to do the work using proc_open works to ensure seperate processes but to be careful you would want to limit the number somehow as well.
Denis Gerasimov
02-Nov-2005 09:19
Many (most?) developers use Win32 platform for PHP Web applications development while production servers mostly run Unix/Linux OS. Below is the stub code I use to make it possible to write scripts on Win32 that use semaphores:

<?php

if (substr(PHP_OS, 0, 3) == 'WIN') {  // if Windows OS detected

   
function ftok($pathname, $proj)
    {
        if (empty(
$pathname) || !file_exists($pathname)) {  // an error occured
           
return -1;
        }
       
       
$pathname = $pathname . (string) $proj;
       
$key = array();
        while (
sizeof($key) < strlen($pathname)) {
           
$key[] = ord(substr($pathname, sizeof($key), 1));
        }
       
        return
dechex(array_sum($key));
    }
   
    function
sem_acquire($sem_identifier)
    {
        return
true;
    }

    function
sem_get($key, $max_acquire = null, $perm = null, $auto_release = null)
    {
        return
true;
    }
   
    function
sem_release($sem_identifier)
    {
        return
true;
    }
   
    function
sem_remove($sem_identifier)
    {
        return
true;
    }
   
}

?>

Of course, there is no way to test semaphores until you have no Unix/Linux test server.
p4nzer at yahoo dot com
01-Nov-2005 10:55
Actually, the way to lock a semaphore from C code appears to be:
<?
    struct sembuf semptr
[2];

    if( (
semid = semget(SEM_KEY, PHP_SEM_NEED_NUMBER, 0666 | IPC_CREAT)) < 0 ) {
       
perror("semget");
        return
1;
    }

   
semptr[0].sem_num = 0;
   
semptr[0].sem_op = -1;
   
semptr[0].sem_flg = SEM_UNDO;
   
semptr[1].sem_num = 1;
   
semptr[1].sem_op 1;
   
semptr[1].sem_flg = SEM_UNDO;

    if(
semop(semid, &semptr[0], 2) < 0 ) {
   
perror("semop");
    }
?>

PS: Disregard the <? and ?>, it's just for pretty printing... this is C code!
hcuevas at galenicom dot com
23-Oct-2003 11:49
Don't use semaphores to serialize access to an undefined number of resources. There is no way (yet) to know before locking if a semaphore is already locked, thus not being able to fully release the semaphore and occupying a semaphore resource for an undefined time.

A possible solution is to build a shared mem pool and store there the current number of locks for a semaphore id.

Cheers,
Horaci Cuevas
david () php net
09-Jul-2003 05:45
Here is a quick utility to dump the contents of a shm_ format memory segment:

http://www.davidc.net/php/shm/
Roman Laptev <tmp at laptev dot org>
02-Apr-2003 11:50
If you going to work with semaphore, which was created by some external program, you can try the following code for this program (C example):

#define SVSEM_MODE (SEM_R | SEM_A | SEM_R>>3 | SEM_R>>6) /* 0644 */
#define PHP_SEM_NEED_NUMBER 3

/*.......*/
int semid, semflag = SVSEM_MODE | IPC_CREAT | IPC_EXCL;
struct sembuf semptr;
union semun semopts;
/*.......*/
if( (semid = semget(sempath, PHP_SEM_NEED_NUMBER, semflag)) >= 0 ) {
  semopts.val = 1; /* initial value for sem */
  if( semctl( semid, 0, SETVAL, semopts) < 0 ) {/*error*/}
  if( semctl( semid, 1, SETVAL, semopts) < 0 ) {/*error*/}
  /* PHP wanna zero for its own semget at third sem.
   * look at ./PHP_SOURCE_PATH/ext/sysvsem/sysvsem.c
   */
  semopts.val = 0;
  if( semctl( semid, 2, SETVAL, semopts) < 0 ) {/*error*/}
}
else if(errno == EEXIST) { /* connect only  */
  if( (semid = semget(sempath, PHP_SEM_NEED_NUMBER, SVSEM_MODE | IPC_CREAT)) < 0 ) {/*error*/}
}
else {/*error*/}

/*.......*/
/* If you want acquire the sem */
  semptr.sem_num = 0;
  semptr.sem_op = -1; /* lock it */
  semptr.sem_flg = SEM_UNDO;
  while( semop(semid, &semptr, 1) < 0 ) {/*error*/}
/*.......*/

Thanks,
Roma
elran70 at hotmail dot com
23-Jun-2002 02:54
Samlpe code for using most of the functions here:

    $MEMSIZE    =   512;//  size of shared memory to allocate
    $SEMKEY     =   1;  //  Semaphore key
    $SHMKEY     =   2;  //  Shared memory key

    echo "Start.\n";
    // Get semaphore
    $sem_id = sem_get($SEMKEY, 1);
    if ($sem_id === false)
    {
        echo "Fail to get semaphore";
        exit;
    }
    else
        echo "Got semaphore $sem_id.\n";

    // Accuire semaphore
    if (! sem_acquire($sem_id))
    {
        echo "Fail to aquire semaphore $sem_id.\n";
        sem_remove($sem_id);
        exit;
    }
    else
        echo "Success aquire semaphore $sem_id.\n";

    $shm_id =   shm_attach($SHMKEY, $MEMSIZE);
    if ($shm_id === false)
    {
        echo "Fail to attach shared memory.\n";
        sem_remove($sem_id);
        exit;
    }
    else
        echo "Success to attach shared memory : $shm_id.\n";

    // Write variable 1
    if (!shm_put_var($shm_id, 1, "Variable 1"))
    {
        echo "Fail to put var 1 on shared memory $shm_id.\n";
        sem_remove($sem_id);
        shm_remove ($shm_id);
        exit;
    }
    else
        echo "Write var1 to shared memory.\n";

    // Write variable 2
    if (!shm_put_var($shm_id, 2, "Variable 2"))
    {
        echo "Fail to put var 2 on shared memory $shm_id.\n";
        sem_remove($sem_id);
        shm_remove ($shm_id);
        exit;
    }
    else
        echo "Write var2 to shared memory.\n";

    // Read variable 1
    $var1   =   shm_get_var ($shm_id, 1);
    if ($var1 === false)
    {
        echo "Fail to retrive Var 1 from Shared memory $shm_id, return value=$var1.\n";
    }
    else
        echo "Read var1=$var1.\n";

    // Read variable 1
    $var2   =   shm_get_var ($shm_id, 2);
    if ($var1 === false)
    {
        echo "Fail to retrive Var 2 from Shared memory $shm_id, return value=$var2.\n";
    }
    else
        echo "Read var2=$var2.\n";

    // Release semaphore
    if (!sem_release($sem_id))
        echo "Fail to release $sem_id semaphore.\n";
    else
        echo "Semaphore $sem_id released.\n";

    // remove shared memory segmant from SysV
    if (shm_remove ($shm_id))
        echo "Shared memory successfully removed from SysV.\n";
    else
        echo "Fail to remove $shm_id shared memory from SysV.\n";

    // Remove semaphore
    if (sem_remove($sem_id))
        echo "semaphore removed successfully from SysV.\n";
    else
        echo "Fail to remove $sem_id semaphore from SysV.\n";
    echo "End.\n";
mikew at php dot net
01-Jun-2001 01:46
As for security,   please look at the perm argument to shm_get.   Shared Memory blocks has the same permission semantics as unix user/group/other file permissions.   As long as your webserver is running as a user that no other users can script to..  and as long as the permissions are set to 600,  you should be fine and have no security concerns.
php at stolt dot de
21-Sep-2000 03:58
The integer keys for sem_get() and shm_attach() have to be systemwide unique. There is no method to ensure that no other process on the system will use your specific key (security! and possible malfunction). Also shared memory is very seldom used there are possibilities for conflicts! To see the used id's you can use the program 'ipcs' (at least under SuseLinux;) ). Thanks Christian C.

이 글은 스프링노트에서 작성되었습니다.

.

'Computer > PHP' 카테고리의 다른 글

MIME 규격  (0) 2012.08.10
base64 규칙  (0) 2012.08.10
세마포어(semaphore)와 공유 메모리(shared memory) 함수  (0) 2012.08.10
PEAR #2 : 간단한 사용법  (0) 2012.08.10
PEAR #1 : 패키지 간편설치  (0) 2012.08.10
configure  (0) 2012.08.10
TAGS.

Comments 0