Shared Memory 函数

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).

down

joeldg at gmail.com ¶

19 years ago

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 


<?php

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

#### 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;

        }

    }

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

?>

down

Roy <roy AT enhost.com> ¶

19 years ago

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


<?php

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 ++;

    }


?>

down

hackie at prohost dot org ¶

19 years ago

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.

down

stoimenov at email dot com ¶

22 years ago

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

 * CreateFileMapping
 * MapViewOfFile

down

Arikania ¶

6 years ago

The shmop implementation as described in this help page is acttually merely a ramdisk / tmpfs that exists only within php, and even only on the linux servers. Or am I missing something?

On windows, the very same functionality can easily be achieved by creating such disk.

In fact, on my own server, I do use a tmpfs disk instead of the - as it appears to me - limited shmop feature.

Why not implement a $_SHARED or $_MUTUAL SuperGlobal in which we can create variables at will, and that is shared by all connections?

This would greatly improve performance of many PHP applications, and could save a lot of burden on server memory. Especially if those variables could be classes containing functions.

You could implement that it is up to the programmer to guard atomicity.

Such superglobal would be feasible on windows servers as well.

down

rei at prohost dot org ¶

24 years ago

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.

down

eddeeboo at gmail dot com ¶

2 months ago

Despite the fact that reads from and writes to the shared memory are not atomic, reading and writing just ONE byte is always atomic. This can be very useful if your application frequently reads and rarely writes "small" chunks of data (~10-15 bytes). You can avoid using any kind of locks by signing your data by 8-bit checksum (like CRC-8). This is an effective and reliable way to ensure that your data is not corrupted. The redundancy is naturally 8 bits.

down

slavapl at mailandnews dot com ¶

24 years ago

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.

＋添加备注

官方地址：https://www.php.net/manual/en/ref.shmop.php

有任何技术问题请点击这里网站运营推广招聘

IT PHP 编程语言开发编程 Linux 科技 Elasticsearch HTML/CSS/XML 面试数据库网络 JAVA NoSQL C/C++ Golang 操作系统 Git 算法正则表达式 Redis 互联网 MySql 软件运维 JavaScript 国际架构设计 Mac OS Excel TCP/IP Windows Oracle Socket Vim VR MongoDB 运营 Python MemCache 商业硬件电子娱乐设计摄影 nginx WordPress 游戏 HTTP 团建数码电器 Docker

php7.3 使用 PDO_DM 扩展连接 DM8 中文乱码 PhpStorm中PHP注释的规范指南使用PHPWord将docx文件转换为html格式 docker-compose启动nginx与php-fpm laravel查看orm生成的sql PHPStorm ESC 会退出命令行 composer install参数 laravel orm中DB::insert方法导致内存泄漏的问题解决方法 php7 安装fileinfo扩展 adodb手册 ADORecordSet对象常用的php ADODB使用方法集锦利用php soap实现web service ADOConnection 公用函数 adodb连接mysql多个数据库的问题 mysql面试题 PHP注释规范 [PHP] inet_pton/inet_ntop IP地址转换函数 PHP7添加redis扩展 php上周一、本周一、下周一日期

略微加速

PHP官方手册 - 互联网笔记

Shared Memory 函数

目录

发现了问题？

用户贡献的备注 9 notes