CXXXII. Shared Memory Functions

简介

Shmop is an easy to use set of functions that allows PHP to read, write, create and delete Unix shared memory segments.

注: Versions of Windows previous to Windows 2000 do not support shared memory. Under Windows, Shmop will only work when PHP is running as a web server module, such as Apache or IIS (CLI and CGI will not work).

注: In PHP 4.0.3, these functions were prefixed by shm rather than shmop.

需求

要编译本扩展模块不需要外部库文件。

安装

To use shmop you will need to compile PHP with the --enable-shmop parameter in your configure line.

运行时配置

本扩展模块在 php.ini 中未定义任何配置选项。

资源类型

预定义常量

本扩展模块未定义任何常量。

范例

例子 1. Shared Memory Operations Overview
<?php // Create 100 byte shared memory block with system id if 0xff3 $shm_id = shmop_open(0xff3, "c", 0644, 100); if (!$shm_id) { echo "Couldn't create shared memory segment\n"; } // Get shared memory block's size $shm_size = shmop_size($shm_id); echo "SHM Block Size: " . $shm_size . " has been created.\n"; // Lets write a test string into shared memory $shm_bytes_written = shmop_write($shm_id, "my shared memory block", 0); if ($shm_bytes_written != strlen("my shared memory block")) { echo "Couldn't write the entire length of data\n"; } // Now lets read the string back $my_string = shmop_read($shm_id, 0, $shm_size); if (!$my_string) { echo "Couldn't read from shared memory block\n"; } echo "The data inside shared memory was: " . $my_string . "\n"; //Now lets delete the block and close the shared memory segment if (!shmop_delete($shm_id)) { echo "Couldn't mark shared memory block for deletion."; } shmop_close($shm_id); ?>

目录
shmop_close -- Close shared memory block
shmop_delete -- Delete shared memory block
shmop_open -- Create or open shared memory block
shmop_read -- Read data from shared memory block
shmop_size -- Get size of shared memory block
shmop_write -- Write data into shared memory block

add a note User Contributed Notes

joeldg at gmail.com
10-Feb-2006 03:28


I wrote a php memcache back in 2003 as a sort of proof of concept

it is use on a few machines for doing heavy page load caching...

it works very well.

Following are some of the core functions I made 

<?           

###############################################

#### shared mem functions

/*

    for debugging these

        use `ipcs` to view current memory

        use `ipcrm -m {shmid}` to remove

        on some systems use `ipcclean` to clean up unused memory if you

        don't want to do it by hand

*/

###############################################

    function get_key($fsize, $file){

        if(!file_exists(TMPDIR.TMPPRE.$file)){

            touch(TMPDIR.TMPPRE.$file);

        }

        $shmkey = @shmop_open(ftok(TMPDIR.TMPPRE.$file, 'R'), "c", 0644, $fsize);

        if(!$shmkey) {

                return false;

        }else{

            return $shmkey;

        }//fi

    }

    function writemem($fdata, $shmkey){

        if(MEMCOMPRESS && function_exists('gzcompress')){

            $fdata = @gzcompress($fdata, MEMCOMPRESSLVL);

        }

        $fsize = strlen($fdata);

        $shm_bytes_written = shmop_write($shmkey, $fdata, 0);

        updatestats($shm_bytes_written, "add");

        if($shm_bytes_written != $fsize) {

                return false;

        }else{

            return $shm_bytes_written;

        }//fi

    }

    function readmem($shmkey, $shm_size){

        $my_string = @shmop_read($shmkey, 0, $shm_size);

        if(MEMCOMPRESS && function_exists('gzuncompress')){

            $my_string = @gzuncompress($my_string);

        }

        if(!$my_string) {

                return false;

        }else{

            return $my_string;

        }//fi

    }

    function deletemem($shmkey){

        $size = @shmop_size($shmkey);

        if($size > 0){ updatestats($size, "del"); }

        if(!@shmop_delete($shmkey)) {

            @shmop_close($shmkey);

                return false;

        }else{

            @shmop_close($shmkey);

            return true;

        }

    }

    function closemem($shmkey){

        if(!shmop_close($shmkey)) {

                return false;

        }else{

            return true;

        }

    }

    function iskey($size, $key){

        if($ret = get_key($size, $key)){

            return $ret;

        }else{

            return false;

        }

    }

################################################

?>

Roy <roy AT enhost.com>
29-Jan-2006 01:58


I have written a script to highlight the superiority of shared memory storage.

Although it doesn't use the shmop function, the underlying concept is similar.

'/shm_dir/' is a tmpfs directory, which is based on shared memory, that I have mounted on the server.



Below is the result on an Intel Pentium VI 2.8 server:



IO test on 1000 files

IO Result of Regular Directory : 0.079015016555786

IO Result of Shared Memory Directory : 0.047761917114258



IO test on 10000 files

IO Result of Regular Directory : 3.7090260982513

IO Result of Shared Memory Directory : 0.46256303787231



IO test on 40000 files

IO Result of Regular Directory : 117.35703110695 seconds

IO Result of Shared Memory Directory : 2.6221358776093 seconds



The difference is not very apparent nor convincing at 100 files.

But when we step it up a level to 10000 and 40000 files, it becomes pretty obvious that Shared Memory is a better contender.



Script courtesy of http://www.enhost.com



<?

set_time_limit(0);



// Your regular directory. Make sure it is write enabled

$setting['regular_dir'] =  '/home/user/regular_directory/';    



// Your shared memory directory. 

$setting['shm_dir'] =  '/shm_dir/';    



// Number of files to read and write

$setting['files'] =  40000;                    



function IO_Test($mode)

{

    $starttime = time()+microtime();



    global $setting;



        for($i = 0 ; $i< $setting['files'] ;$i++)

        {

            $filename = $setting[$mode].'test'.$i.'.txt';

            $content = "Just a random content";

        

                // Just some error detection

               if (!$handle = fopen($filename, 'w+')) 

               {

                     echo "Can't open the file ".$filename;

                     exit;

               }

            

               if (fwrite($handle, $content ) === FALSE) 

               {

                   echo "Can't write to file : ".$filename;

                   exit;

               }

              

               fclose($handle);

            

            // Read Test

            file_get_contents($filename);

    

        }



   $endtime = time()+microtime(); 

   

   $totaltime = ($endtime - $starttime); 

   

   return $totaltime;



}



echo '<b>IO test on '.$setting['files']. ' files</b><br>';

echo 'IO Result of <b>Regular</b> Directory : '.IO_Test('regular_dir')   .' seconds<br>';

echo 'IO Result of <b>Shared Memory</b> Directory : '.IO_Test('shm_dir')       .' seconds<br>';



/* Removal of files to avoid underestimation

#

#         Failure to remove files will result in inaccurate benchmark

#         as it will result in the IO_Test function not re-creating the existing files 

*/ 

    foreach ( glob($setting['regular_dir']."*.txt") as $filename) {

       unlink($filename);$cnt ++;

    }

    foreach ( glob($setting['shm_dir']."*.txt") as $filename) {

       unlink($filename);$cnt ++;

    }



?>

hackie at prohost dot org
27-Sep-2005 12:33


It's not the job of the shmop extension to provide locking, there are many locking schemes avalible, if you need some sort of atomic operations choose a locking scheme that suits you and use it.

adamstevenson at _NOSPAM_ gmail dot com
13-Apr-2005 03:12


Here is a little caching script that uses shared memory.  It provides some examples on how to use some of the functions. http://www.adamstevenson.net/mycached.phps

Helped me to cut down some of my page requests from 2 seconds to .035 seconds.

Craig Manley
07-Jan-2005 07:19


Since there is no mention of the (lack of) need for locking here, I took a look into the shmop.c extensions code. So correct me if I'm wrong, but the shmop.c extension uses memcpy() to copy strings to and from shared memory without any form of locking, and as far as I know, memcpy() is not atomic.



If that's true as I suspect, then these 'easy to use' functions are not so 'easy to use' any more and have to be wrapped in locks (e.g. semaphores, flocks, whatever).

joeldg AT listbid.com
03-May-2003 03:48


Just so you know, the ftok function is probably the best for getting the key.. just so there are not people confused with how they are coming up with these hex codes for the id.



$fsize = filesize("/home/joeldg/testdata");

$fdata = file_get_contents("/home/joeldg/testdata");

$shm_id = shmop_open(ftok("/home/joeldg/testdata", 'R'), "c", 0644, $fsize);

stoimenov at email dot com
24-Jul-2002 08:18


Windows does support shared memory through memory mapped file. Check the following functions for details:



 * CreateFileMapping

 * MapViewOfFile

hackie at misato dot prohost dot org
02-May-2002 09:15


Your segment probobly doesn't exist. You should probobly be using the c flag... 



      "a" for access (sets SHM_RDONLY for shmat) use this flag when you need to open an existing shared memory segment for read only



      "c" for create (sets IPC_CREATE) use this flag when you need to create a new shared memory segment or if a segment with the same key exists, try to open it for read and write

rei at prohost dot org
12-Jan-2001 07:16


The idea behind SHMOP is an easy to use shared memory interface, 


without any additional headers added to the shared memory segment 


or requiring any special special controls to access the shared memory


segment outside of PHP. SHMOP borrows its api from C's api to shm,


which makes it very easy to use, because it treats shared memory, like C, as    


a file of sorts. This makes it very easy to use even for novices, due to this  


functionality. Most importantly SHMOP uses shm segments to store raw data,


which means you don't need to worry about matching headers, etc... when you are


using C, perl or other programming languages to open/create/read/write shm segments


that were create or are going to be used by PHP. In this it differs from


sysvshm, who's shm interface uses a specialized header, which resides inside


the shared memory segment this adds an unnecessary level of difficulty when


you want to access php shm from external programs.


Also, from my personal tests in Linux 2.2/2.4 and FreeBSD 3.3 SHMOP is about


20% faster then sysvshm, mostly due to fact it does not need to parse the


specialized header and stores the data in raw form.

slavapl at mailandnews dot com
12-Jan-2001 07:02


What you need to realise is that sysvshm is extremly php oriented in it's ability, it's quite a kludge interfacing other NON PHP utilities with it. For example have you tried using sysvshm to read an shm segment NOT created by php? It's not possible, because sysvshm uses a proprietry format, in essense it can ONLY be used within PHP unless of course you take time to figure out this format. 


So basically, the purpose of shmop is to provide a symple interface to shared memory that can be used with OTHER NON php shm creators. 





Hope this clears it up.

add a note