Если у кого есть идеи, как организовать иную атомарную операцию вместо файла семафора которая будет в 100500 раз быстрее, то вэлком

Есть еще одна проблема, с синхронизацией вопрос решен, теперь лишние данные не будут попадать в read, write будет скажем так ждать пока данные прочитаются в другом скрипте. Но тут возникла еще одна проблема, это, то, что много холостых итераций цикла. Решение? Полинг! Но его не прикрутишь просто так, подумал прикрутить к shmop libevent, и через локальный сокет отсылать данные о готовности, но как понимаете это все полная хрень, множественные задержки будут лишние, так что организация полноценного полинга не реальна. Можно обойтись обычным usleep для скрипта писаря, который пишет данные. Для клиента можно не делать, если например конструкция происходит следующим образом:

скрипт 1: сокет сервер слушающий (libevent), некоторый клиент запросил файл.
скрипт 1 запустил скрипт 2, который читает этот файл и передает данные через shmop (fread блочит поток, поэтому нам не подходит чтение файла в том же скрипте, поэтому использовали отдельный скрипт 2 который занимается исключительно чтением файлов и передачей их через shmop.)

скрипт 2 читает файл и пишет его в shmop, скрипт 1 читает данные из shmop и отправляет на сокет, после чего вешается колбэк на готовность сокета на запись, и вот оно чудо поллинг )))

Осталось решить проблему полинга для скрипта 2, который не должен жрать проц.

Причание: скрипт 2 будет читать в себя не весь файл сразу, а только ровно столько сколько нужно для скрипта 1 с буфером 512 кб. на файл.

Такая конструкция устранит задержки на файловый I/O в скрипте 1 и он сможет работать за доли миллисекунд, при этом сможет получать бинарные данные с минимальными затратами, всю грязную работу будет выполнять скрипт 2

Можно было заюзать EIO, но я не ищу простых путей..

честно говоря я не совсем даже понял что это такое)))
работа с памятью?
сорри сейчас прочитал понял.))

Ага, щас класс дописываю, двунаправленной связи пока нет. И вхожу в состояние фен-шуй, чтобы догадаться как полинг внедрить.

Накосячил

shmop_write($this->shmop_key, strlen($data)."\0", 0);
// Write data offset (maximum size self::$header_size)
shmop_write($this->shmop_key, $data, self::$header_size);

1 байт бинарных данных затирается :lol:

Короче так не реально, буду спецификацию протокола передачи данных через shmop писать. А то фен-шуй не помогает.

Развивай класс. И потом выложи - полезная может выйти штука.

Пытаюсь по минимуму использовать ресурсы, чтобы скорость существенно не провалилась, но уже есть просадка 2.67 гига в сек выдает

Если вообще убрать все и только писать, выдает 13 - 14 гигов в сек, как в нативе прям

Я подумал забить на составление протокола, и для каждого файла делать свой сегмент shmop, в этом случае не придется, управлять очередью файлов, но тогда shmop будет не эффективно использоваться, да и по дефолту есть ограничение на количество сегментов, это придется конфиги ядра дергать.

Вот черновик:

Заголовок Данные
/--------------------------------------------------------------\/----------------------------\
| Команды | Параметры команд | Размер данных | Бинарные данные

Команды - (1 байт)
Параметры команд (2 байт)
Длина файла (6 байт)
--- Итого 9 байт заголовок.
Бинарный данные (Размер сегмента shmop)

Список команд:

\0 - NULL Данные после этого символа доджны игнорироваться.(прекращает чтение на этом символе).
\1 - SOH Команда указывает, на то, что есть данные которые можно прочитать.
\4 - EOT Если все блоки были переданы, для завершения и очищения дескрипторов требуется отправить EOT, на стороне клиента будет означать конец файла(EOF).
\5 - ENQ Запрос файла.
\11 - DC1 Запрос на передачу следующего блока данных.
\18 - CAN Отменяет передачу файла.

Пояснения
DC1

Получатель данных работает асинхронно, а скрипт отправитель работает синхронно, может возникнуть ситуация, когда мы запросили файл, в ответ нам ничего не вернется, в этом случае,
требуется пропустить передачу и вновь повторить попытку чтения позже. Так как у нас всего 1 сегмент, а файлов много, требуется команда DC1 с указанием идентификатора файла, скорее всего в этот же момент, скрипт не получит
овтета с новым блоком данных, поэтому нужно пропустить операцию и вернуться к ней позже. (Можно попробывать организовать костыльный полинг за счет работы flock, через него мы сможем ловить сигналы и не тратить
лишнее процессорное время, за счет того, что flock блокируется и ожидает разблокировки файла.)

Параметры команд:
1. NULL - без параметров.
2. SOH + Номер файла + Идентификатор файла + Размер данных + Бинарные данные
3. EOT + Номер файла + Идентификатор файла
4. ENQ + Номер файла + Идентификатор файла + Размер данных + Бинарные данные
5. DC1 + Номер файла
6. CAN + Номер файла + Идентификатор файла

Общие символы:

\0 конец zero-string.
Параметры команд и длина файла имеют фиксированный размер, если в параметры команд или длину файла передаются данные меньше чем фиксированный размер, требуется завершить данные NULL символом.

Пример формирования команд:

Запрос на передачу файла:

ENQ7NULL11....c:\test.php

или

ENQ7216....c:\test\test.php

(точки псевдосимвол пропуска каких либо данных)
Запись данных таких как c:\test.php, должен начинаться со смещением в 9 байт, т.е запись производтся начиная с 10 байта.

Размеры:
1. Команда 1 байт.
2. Параметр команды 1 байт + NULL символ (выделено 2 байта)
3. Длина файла 2 байта + NULL символ (выделено 6 байт)
4. Данные 11 байт.(выделено *параметры shmop сегмента)

Передача данных:

SOH7NULL11....[BINARY DATA]

Отмена передачи данных:

CAN7

Передача данных завершена:

EOT7

Запрос на передачу следующего блока данных:

DC17


---------------

В этой схеме меня беспокоит одно:

Это очередь которая возникает на передачу кусков файлов. На стороне сервера нужно будет формировать стэк запросов на получение кусков. С другой стороны от стэка будет выигрышь в том, что частота запросов кусков будет зависеть от канала клиента, если он узкий, то в стэк будет поподать меньше команд на запрос кусков, а если канал широкий, то команд запросов кусков будет намного больше. С другой стороны может возникнуть конкуренция, и если размер стэка будет большим, может произойти так, что будут задержки на получение куска файла для определенных клиентов.

Вот кое, что есть:

winshmop.class.php

class WINSHMOP
{
	private $shmop_key;
	private $shmop_mode;
	private $shmop_semaphor_fd;
	private $shmop_semaphor_path;
	private $shmop_fd_array = array();
	public static $header_size = 6; // Max 999 999 bytes recv
	public static $header_com_size = 2; // Max 99 files ids
	
	function __destruct()
	{
		if(!$this->shmop_key)
			return;

		if($this->shmop_mode == 'c')
			$this->delete();
		$this->close();
	}

	public function open($fullpath, $flags, $mode = 0, $block_size = 0)
	{
		// Add header size
		if($block_size != 0)
			$block_size += self::$header_size;
			
		$shmop_key = self::key($fullpath);

		$shm_id = shmop_open($shmop_key, $flags, $mode, $block_size);
		if(!$shm_id)
			return false;
		
		$this->shmop_mode = $mode;
		$this->shmop_semaphor_path = dirname($fullpath).'/'.$shmop_key.'.sem';
		$this->shmop_semaphor_fd = fopen($this->shmop_semaphor_path, 'c');
		$this->shmop_key = $shm_id;
		return true;
	}
	
	public function lock($operation)
	{
		flock($this->shmop_semaphor_fd, $operation ? LOCK_EX : LOCK_UN);
	}
	
	public function getcommand()
	{
		return shmop_read($this->shmop_key, 0, 1);
	}

	// First call this, you need call read.
	// return false or int number of fid.
	public function getfile($data)
	{
		// Get command
		$command = (int)shmop_read($this->shmop_key, 0, 1);

		if($command !== 0)
			return false;

		// Maximum files by header length
		if(strlen(count($this->shmop_fd_array)) > self::$header_com_size)
			return null;
		
		// Generate max files fd.
		$array_max_files_fd = '1';
		$array_max_files_fd = (int)str_pad($array_max_files_fd, self::$header_com_size+1, '0');
		
		// Check free fd array
		$current_fid = 0;
		for($i=0;$i<$array_max_files_fd;$i++)
		{
			if(!isset($this->shmop_fd_array[$i]))
			{
				$this->shmop_fd_array[$i] = true;
				$current_fid = $i;
				break;
			}
		}

		// Check current fid lenght and add zero symbol.
		if(strlen($current_fid) < self::$header_com_size)
			$command_param = $current_fid."\0";
		else
			$command_param = $current_fid;
			
		$datasize = strlen($data);
		
		// Check datasize header lenght and add zero symbol.
		if(strlen($datasize) < self::$header_size)
			$datasize .= "\0";

		// Write header: ENQ,FID,DATASIZE
		shmop_write($this->shmop_key, "\5".$command_param.$datasize, 0);

		// Write data: DATA
		shmop_write($this->shmop_key, $data, 1+self::$header_com_size+self::$header_size);
		
		// Return FID
		return $current_fid;
	}
	public function getchunk($current_fid)
	{
		if(strlen($current_fid) < self::$header_com_size)
			$current_fid .= "\0";

		shmop_write($this->shmop_key, "\11".$current_fid, 0);	
	}

	public function read()
	{
		// Get command
		$command = shmop_read($this->shmop_key, 0, 1+self::$header_com_size);
		
		if($command[0] === "\0")
			return '';
		else if($command[0] === "\1")
		{
			// Get current FID
			$current_fid = (int)substr($command, 1);
			// Get datasize header
			$datasize = (int)shmop_read($this->shmop_key, 1+self::$header_com_size, self::$header_size);
			$data = shmop_read($this->shmop_key, 1+self::$header_com_size+self::$header_size, $datasize);
			
			// Clear read
			shmop_write($this->shmop_key, "\0", 0);
			
			return array('fid' => $current_fid, 'type'=> 'getfile', 'data' =>$data);
		}
		else if($command[0] === "\11")
		{
			// Clear read
			shmop_write($this->shmop_key, "\0", 0);
			// Get current FID
			return (int)substr($command, 1);
		}
		else if($command[0] === "\5")
		{
			// Get current FID
			$current_fid = (int)substr($command, 1);
			// Get datasize header
			$datasize = (int)shmop_read($this->shmop_key, 1+self::$header_com_size, self::$header_size);
			$data = shmop_read($this->shmop_key, 1+self::$header_com_size+self::$header_size, $datasize);
			
			// Clear read
			shmop_write($this->shmop_key, "\0", 0);

			return array('fid' => $current_fid, 'type'=> 'getfile', 'data' =>$data);
		}
	}

	public function write($data, $current_fid)
	{
		// Get command
		$command = shmop_read($this->shmop_key, 0, 1+self::$header_com_size);
		
		if($command[0] !== "\0")
			return false;

		// Check current fid lenght and add zero symbol.
		if(strlen($current_fid) < self::$header_com_size)
			$command_param = $current_fid."\0";
		else
			$command_param = $current_fid;
			
		// Check datasize header lenght and add zero symbol.
		$datasize = strlen($data);
		if(strlen($datasize) < self::$header_size)
			$datasize .= "\0";

		// Write header: ENQ,FID,DATASIZE
		shmop_write($this->shmop_key, "\1".$command_param.$datasize, 0);

		// Write data: DATA
		shmop_write($this->shmop_key, $data, 1+self::$header_com_size+self::$header_size);
		
		return true;
	}
	
	public function close()
	{
		if(shmop_close($this->shmop_key))
			return true;
		else
			return false;
	}

	private function delete()
	{
		fclose($this->shmop_semaphor_fd);
		unlink($this->shmop_semaphor_path);

		if(shmop_delete($this->shmop_key))
			return true;
		else
			return false;
	}
	
	public static function key($fullpath = __FILE__)
	{
		return "0x".hash('crc32', $fullpath).hash('crc32', basename($fullpath));
	}
}

function convert($size)
{
    $unit=array('b','kb','mb','gb','tb','pb');
    return @round($size/pow(1024,($i=floor(log($size,1024)))),2).' '.$unit[$i];
}

function get_micro_time()
{
	list($usec, $sec) = explode(" ",microtime());
	return ((float)$usec + (float)$sec);
}

shmop_reader.php

<?php

require_once('shmop.class.php');

$WINSHMOP = new WINSHMOP;

if(!$WINSHMOP->open('C:\LibeventPHP\test\shmop.php', 'w'))
{
	echo 'cannot open block';
	exit;
}

$reads_microtime = 0;
$reads_ps = 0;

$files_array = array();
$pop_array[] = array();

$WINSHMOP->lock(true);
$fid = $WINSHMOP->getfile('C:\LibeventPHP\test\shmop.php');
$WINSHMOP->lock(false);

$files_array[] = $fid;
$pop_array = $files_array;

while(1)
{
	$times = get_micro_time();
	$WINSHMOP->lock(true);
	
	$command = $WINSHMOP->getcommand();

	if($command === "\0")
	{
		$key = key($pop_array);
		$WINSHMOP->getchunk($pop_array[$key]);
		$WINSHMOP->lock(false);
		unset($pop_array[$key]);
		continue;
	}
	else if($command !== "\1")
	{
		usleep(1000);
		continue;
	}

	$data_str = $WINSHMOP->read();
	
	if(count($files_array) < 50)
	{
		$files_array[] = $WINSHMOP->getfile('C:\LibeventPHP\test\shmop.php');
	}
	
	if(count($pop_array) === 0)
	{
		$pop_array = $files_array;
	}

	if($data_str !== '')
	{
		$reads_ps++;
	}
	$WINSHMOP->lock(false);

	$reads_microtime += round(((get_micro_time() - $times ) * 1000), 3);
	
	if($reads_microtime > 1000)
	{
		echo 'Reads per sec: '.$reads_ps.' Data size per sec: '.convert(strlen($data_str['data']) * $reads_ps)."\n";
		echo 'FID: '.$data_str['fid'].' Len: '.strlen($data_str['data'])."\n";
		$reads_ps = 0;
		$reads_microtime = 0;
	}
}

?>

shmop_writer.php

<?php

require_once('shmop.class.php');

$WINSHMOP = new WINSHMOP;

if(!$WINSHMOP->open('C:\LibeventPHP\test\shmop.php', 'c', 0644, 200000))
{
	echo 'cannot create block';
	exit;
}

$writes_microtime = 0;
$writes_ps = 0;


$data_str = '';
for($i=0;$i<10000;$i++)
{
	$data_str .= 'Test data string';
}

$data_str_len = strlen($data_str);
$array_fid = array();

while(1)
{
	$times = get_micro_time();

	$WINSHMOP->lock(true);
	$command = $WINSHMOP->getcommand();

	if($command === "\11") // Get chunk
	{
		$fid = $WINSHMOP->read();
		$add_bytes = '';
		$add_bytes = str_pad($add_bytes, $fid, '0'); // Просто, чтобы размер данных различался.
		$WINSHMOP->write($data_str.$add_bytes, $fid);
		$writes_ps++;
	}
	else if($command === "\5") // Get file
	{
		$command = $WINSHMOP->read();
		$array_fid[] = $command['fid'];
		//var_dump($command);
	}
	else if(count($array_fid) === 0) // Do nothing
	{
		$WINSHMOP->lock(false);
		usleep(1000);
		continue;
	}

	$WINSHMOP->lock(false);
	
	$writes_microtime += round(((get_micro_time() - $times ) * 1000), 3);
	
	if($writes_microtime > 1000)
	{
		echo 'Writes per sec: '.$writes_ps.' Data size per sec: '.convert($data_str_len * $writes_ps)."\n";
		$writes_ps = 0;
		$writes_microtime = 0;
	}
}

?>

Жуткий говнокод, но это тестовая модель.

Собственно замеры:


Writes per sec: 6913 Data size per sec: 1.03 gb
Writes per sec: 7690 Data size per sec: 1.15 gb
Writes per sec: 7862 Data size per sec: 1.17 gb
Writes per sec: 6595 Data size per sec: 1006.32 mb
Writes per sec: 8056 Data size per sec: 1.2 gb
Writes per sec: 7513 Data size per sec: 1.12 gb
Writes per sec: 7531 Data size per sec: 1.12 gb
Writes per sec: 7544 Data size per sec: 1.12 gb
Writes per sec: 7144 Data size per sec: 1.06 gb
Writes per sec: 7650 Data size per sec: 1.14 gb
Writes per sec: 7761 Data size per sec: 1.16 gb
Writes per sec: 7352 Data size per sec: 1.1 gb
Writes per sec: 7114 Data size per sec: 1.06 gb
Writes per sec: 7264 Data size per sec: 1.08 gb
Writes per sec: 7383 Data size per sec: 1.1 gb
Writes per sec: 7639 Data size per sec: 1.14 gb
Writes per sec: 7872 Data size per sec: 1.17 gb
Writes per sec: 7486 Data size per sec: 1.12 gb
Writes per sec: 7593 Data size per sec: 1.13 gb


Reads per sec: 9866 Data size per sec: 1.47 gb
FID: 2 Len: 160002
Reads per sec: 10032 Data size per sec: 1.5 gb
FID: 34 Len: 160034
Reads per sec: 10029 Data size per sec: 1.49 gb
FID: 13 Len: 160013
Reads per sec: 10036 Data size per sec: 1.5 gb
FID: 49 Len: 160049
Reads per sec: 10027 Data size per sec: 1.49 gb
FID: 26 Len: 160026
Reads per sec: 10038 Data size per sec: 1.5 gb
FID: 14 Len: 160014
Reads per sec: 10012 Data size per sec: 1.49 gb
FID: 26 Len: 160026
Reads per sec: 10035 Data size per sec: 1.5 gb
FID: 11 Len: 160011
Reads per sec: 10027 Data size per sec: 1.49 gb
FID: 38 Len: 160038
Reads per sec: 10029 Data size per sec: 1.49 gb
FID: 17 Len: 160017
Reads per sec: 10029 Data size per sec: 1.49 gb
FID: 46 Len: 160046
Reads per sec: 10030 Data size per sec: 1.49 gb
FID: 26 Len: 160026
Reads per sec: 10025 Data size per sec: 1.49 gb
FID: 1 Len: 160001
Reads per sec: 10038 Data size per sec: 1.5 gb
FID: 39 Len: 160039


-------------

Осталось внести оптимизации, думаю сделать константами размер заголовков, не думаю, что кто либо будет гонять больше 99 файлов одновременно и при этом в сегмент засовывать больше 999999 байт инфы. Хотя... Вобщем еще осталось прицепить костыльный полинг, через flock.

Подпилил класс, замерил скорость, ну кароче это EPIC FAIL. Выигрыш от уменьшения задержек минимальный, при этом мы получаем массу гемороев таких как shm сегмент который может коряво быть настроен и тд. Думаю мой демон переживет задержку на чтение в fread на 1 ms...

Но если количество запросов к либевенту будет много, эта 1 мс может превратиться в 1000 мс и сокеты будут тупить и не выполнять другие задачи. Так же fread иногда любит тупануть на пару сотен мс, пока головки найдут инфу и начнут с ней работать.

ППц стока гемороя, чтобы сделать обыкновенный тред, я балдю