Single process memory model for opcache in ZTS

[dktapps]

Description

In ZTS, all requests run inside the same process, so there's no need for coordination between different processes.
This means that a non-SHM memory model could be used, and a lock file could be replaced by a regular mutex.

This would be beneficial for applications that run exclusively in ZTS and create userland threads, such as PocketMine-MP. PocketMine already uses ZTS and opcache CLI in most places, but it's currently unable to assume opcode caching is always available due to some platforms restricting access to certain lockfile features and SHM, such as Android.
PocketMine has a lot of users who insist on running servers on their mobile devices for some reason, so they'd stand to benefit :)

Since classes and op_arrays in general are non-thread-safe by default, threading extensions benefit a ton from Opcache since Opcache makes op_arrays and many other structures thread-safe by design, so they don't need to be copied. However, because Opcache uses features that are restricted on some platforms - features which are not necessary when running in ZTS mode and creating user threads - the likes of ext-pmmpthread still have to copy-paste large amounts of code from zend_persist.c to provide this functionality if Opcache is not available. If Opcache had a non-SHM memory model that didn't require lockfiles, mmap or any other fancy stuff, this would allow my threading extension to assume Opcache will always be available and caching code, which would potentially allow me to delete an insane amount of code and massively reduce the maintenance burden of the extension.

I don't know if there might be some advantages for ZTS in general (perhaps lower overhead?) but this doesn't seem like a hard change in any case as far as I can understand, so I thought I'd float the suggestion.

[iluuu1994]

I think there's no need for a singular memory pool when using ZTS at all. It does have some benefits (cache locality), but sharing malloc'd allocations directly would have the benefit that invalidated scripts can simply be freed, rathern than slowly filling shm. It would also become possible to discard JIT code that is unprofitable, or that has been further optimized with a higher-tier JIT.

[dktapps]

Sure, that makes sense and would probably be better. The reason I suggest it this way is that the API for SHM is literally 3 functions, so it'd probably be pretty easy to throw something together. As far as I can tell, all it'd need would be implementing these and replacing the lockfile with a mutex:

php-src/ext/opcache/zend_shared_alloc.h

Lines 87 to 91 in 13411ef

	typedef struct {
	create_segments_t create_segments;
	detach_segment_t detach_segment;
	size_t (*segment_type_size)(void);
	} zend_shared_memory_handlers;

php-src/ext/opcache/zend_shared_alloc.c

Line 83 in 13411ef

void zend_shared_alloc_create_lock(char *lockfile_path)

I'm not sure about the complexity of changing over to using malloc directly though. That looks like a lot more stuff would have to be re-implemented, although it's hard to tell how much of the stuff in zend_shared_alloc.h is allocator-specific vs generic logic.