[Proposal] opcache.no_cache: Opcode optimization without caching

Currently, it isn't possible to enable optimizations without enabling caching.
They should be orthogonal features - it's already possible to cache without
optimization passes (`opcache.optimization_level=0`)

Being forced to either enable caching or file_cache_only causes these problems:

- For file_cache_only, users would be forced to manage the file cache,
  and users may not be confident in properly handling all potential edge cases.

  (Running out of disk space, need to clear stale entries, concerns about opcode
  corruption not being fixed after restarting a process, etc)
- The shared memory block uses up a lot of RAM when individual PHP processes
  are known to be long-lived and don't have a common memory address space.
  (e.g. multiple long-lived php scripts managed by something that is not
  a php script (e.g. `supervisord`, daemons, tools run in the background in
  IDEs, etc))

  The opcodes are duplicated in shmem, which wastes memory in use cases
  where they're stored in the cache but never retrieved.

  The default for opcache.memory_consumption is 128M.
  Even when this isn't used, the virtual memory to track the shared
  memory(shmem) segment seems to add 2MB extra per **independent** php process in
  "shared memory" segments, reducing the free RAM available for other processes.

  (starting a large number of php CLI scripts that sleep() in a loop,
  `free` (linux program to report free memory) reports that `shared`
  increases by 2MB per process without opcache.no_cache, but barely increases
  with opcache.no_cache=1

On an unrelated PR php#5097 (comment)
dstogov mentioned that

> Also, it would be great to move optimizer and JIT into core, to make them
> available even without opcode caching.

This PR is one potential approach for making the optimizer and JIT available
without opcode caching.

This is currently a proof of concept - feel free to point out combinations of
settings that should be rejected.

Potential areas for future work:

- Normally, opcache optimizes a file based only on that one file's contents.
  When `opcache.no_cache=1` is used, it may be possible to use all of the
  class, function, constant, etc. definitions parsed from previously parsed
  files (to eliminate dead code, inline function calls, etc).

Author: TysonAndre

ext/opcache/ZendAccelerator.c

@@ -114,6 +114,7 @@ zend_bool accel_startup_ok = 0;
 static char *zps_failure_reason = NULL;
 char *zps_api_failure_reason = NULL;
 zend_bool file_cache_only = 0;  /* process uses file cache only */
+zend_bool no_cache = 0;  /* process does not use any cache */
 #if ENABLE_FILE_CACHE_FALLBACK
 zend_bool fallback_process = 0; /* process uses file cache fallback */
 #endif
@@ -468,7 +469,7 @@ zend_string* ZEND_FASTCALL accel_new_interned_string(zend_string *str)
 	uint32_t     pos, *hash_slot;
 	zend_string *s;
 
-	if (UNEXPECTED(file_cache_only)) {
+	if (UNEXPECTED(file_cache_only || no_cache)) {
 		return str;
 	}
 
@@ -1886,6 +1887,28 @@ zend_op_array *file_cache_compile_file(zend_file_handle *file_handle, int type)
 	return op_array;
 }
 
+// Optimize opcodes without caching the file in shared memory or in disk
+zend_op_array *no_cache_compile_file(zend_file_handle *file_handle, int type)
+{
+	zend_op_array *op_array = NULL;
+	zend_persistent_script *persistent_script;  // not actually persistent with opcache.no_cache.
+
+	if (is_stream_path(file_handle->filename) &&
+	    !is_cacheable_stream_path(file_handle->filename)) {
+		return accelerator_orig_compile_file(file_handle, type);
+	}
+
+	// Take the same code path as if attempting to save a blacklisted script to file cache.
+	persistent_script = opcache_compile_file(file_handle, type, NULL, &op_array);
+	if (persistent_script) {
+		// Attempt to optimize the script before returning it.
+		zend_optimize_script(&persistent_script->script, ZCG(accel_directives).optimization_level, ZCG(accel_directives).opt_debug_level);
+
+		return zend_accel_load_script(persistent_script, /* from_memory */ 0);
+	}
+	return op_array;
+}
+
 int check_persistent_script_access(zend_persistent_script *persistent_script)
 {
     char *phar_path, *ptr;
@@ -1922,15 +1945,23 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type)
 		ZCG(cache_opline) = NULL;
 		ZCG(cache_persistent_script) = NULL;
 		if (file_handle->filename
-		 && ZCG(accel_directives).file_cache
 		 && ZCG(enabled) && accel_startup_ok) {
-			return file_cache_compile_file(file_handle, type);
+		    if (ZCG(accel_directives).file_cache) {
+				return file_cache_compile_file(file_handle, type);
+			} else if (no_cache) {
+				return no_cache_compile_file(file_handle, type);
+			}
 		}
 		return accelerator_orig_compile_file(file_handle, type);
 	} else if (file_cache_only) {
 		ZCG(cache_opline) = NULL;
 		ZCG(cache_persistent_script) = NULL;
 		return file_cache_compile_file(file_handle, type);
+	} else if (no_cache) {
+		// TODO: Why is opcache_get_status using accelerator_enabled instead of enabled?
+		ZCG(cache_opline) = NULL;
+		ZCG(cache_persistent_script) = NULL;
+		return no_cache_compile_file(file_handle, type);
 	} else if (!ZCG(accelerator_enabled) ||
 	           (ZCSG(restart_in_progress) && accel_restart_is_active())) {
 		if (ZCG(accel_directives).file_cache) {
@@ -2251,7 +2282,7 @@ static int persistent_stream_open_function(const char *filename, zend_file_handl
 /* zend_resolve_path() replacement for PHP 5.3 and above */
 static zend_string* persistent_zend_resolve_path(const char *filename, size_t filename_len)
 {
-	if (!file_cache_only &&
+	if (!file_cache_only && !no_cache &&
 	    ZCG(accelerator_enabled)) {
 
 		/* check if callback is called from include_once or it's a main request */
@@ -2375,7 +2406,7 @@ int accel_activate(INIT_FUNC_ARGS)
 	ZCG(cwd_key_len) = 0;
 	ZCG(cwd_check) = 1;
 
-	if (file_cache_only) {
+	if (file_cache_only || no_cache) {
 		ZCG(accelerator_enabled) = 0;
 		return SUCCESS;
 	}
@@ -2931,7 +2962,8 @@ static int accel_post_startup(void)
 /* End of non-SHM dependent initializations */
 /********************************************/
 	file_cache_only = ZCG(accel_directives).file_cache_only;
-	if (!file_cache_only) {
+	no_cache = ZCG(accel_directives).no_cache;
+	if (!file_cache_only && !no_cache) {
 		size_t shm_size = ZCG(accel_directives).memory_consumption;
 #ifdef HAVE_JIT
 		size_t jit_size = 0;
@@ -3023,10 +3055,14 @@ static int accel_post_startup(void)
 		zend_shared_alloc_unlock();
 
 		SHM_PROTECT();
-	} else if (!ZCG(accel_directives).file_cache) {
+	} else if (file_cache_only && !ZCG(accel_directives).file_cache) {
 		accel_startup_ok = 0;
 		zend_accel_error(ACCEL_LOG_FATAL, "opcache.file_cache_only is set without a proper setting of opcache.file_cache");
 		return SUCCESS;
+	} else if (no_cache && ZCG(accel_directives).file_cache) {
+		accel_startup_ok = 0;
+		zend_accel_error(ACCEL_LOG_FATAL, "opcache.no_cache cannot be combined with opcache.file_cache");
+		return SUCCESS;
 	} else {
 		accel_shared_globals = calloc(1, sizeof(zend_accel_shared_globals));
 
@@ -3083,7 +3119,7 @@ static int accel_post_startup(void)
 
 	zend_optimizer_startup();
 
-	if (!file_cache_only && ZCG(accel_directives).interned_strings_buffer) {
+	if (!file_cache_only && !no_cache && ZCG(accel_directives).interned_strings_buffer) {
 		accel_use_shm_interned_strings();
 	}
 
@@ -3101,6 +3137,7 @@ void accel_shutdown(void)
 {
 	zend_ini_entry *ini_entry;
 	zend_bool _file_cache_only = 0;
+	zend_bool _no_cache = 0;
 
 #ifdef HAVE_JIT
 	zend_jit_shutdown();
@@ -3122,15 +3159,16 @@ void accel_shutdown(void)
 	}
 
 	_file_cache_only = file_cache_only;
+	_no_cache = no_cache;
 
 	accel_reset_pcre_cache();
 
 #ifdef ZTS
 	ts_free_id(accel_globals_id);
 #endif
 
-	if (!_file_cache_only) {
-		/* Delay SHM detach */
+	if (!_file_cache_only && !_no_cache) {
+		/* Delay SHM detach - this only needs to be done if SHM is used */
 		orig_post_shutdown_cb = zend_post_shutdown_cb;
 		zend_post_shutdown_cb = accel_post_shutdown;
 	}
@@ -4747,6 +4785,10 @@ static int accel_finish_startup(void)
 			zend_accel_error(ACCEL_LOG_WARNING, "Preloading doesn't work in \"file_cache_only\" mode");
 			return SUCCESS;
 		}
+		if (UNEXPECTED(no_cache)) {
+			zend_accel_error(ACCEL_LOG_WARNING, "Preloading doesn't work in \"no_cache\" mode");
+			return SUCCESS;
+		}
 
 		/* exclusive lock */
 		zend_shared_alloc_lock();

ext/opcache/ZendAccelerator.h

@@ -177,6 +177,7 @@ typedef struct _zend_accel_directives {
 #endif
 	char          *file_cache;
 	zend_bool      file_cache_only;
+	zend_bool      no_cache;
 	zend_bool      file_cache_consistency_checks;
 #if ENABLE_FILE_CACHE_FALLBACK
 	zend_bool      file_cache_fallback;
@@ -290,6 +291,7 @@ extern char accel_uname_id[32];
 #endif
 extern zend_bool accel_startup_ok;
 extern zend_bool file_cache_only;
+extern zend_bool no_cache;
 #if ENABLE_FILE_CACHE_FALLBACK
 extern zend_bool fallback_process;
 #endif

ext/opcache/zend_accelerator_module.c

@@ -240,6 +240,7 @@ ZEND_INI_BEGIN()
 #if ENABLE_FILE_CACHE_FALLBACK
 	STD_PHP_INI_ENTRY("opcache.file_cache_fallback"           , "1"   , PHP_INI_SYSTEM, OnUpdateBool,	   accel_directives.file_cache_fallback,           zend_accel_globals, accel_globals)
 #endif
+	STD_PHP_INI_ENTRY("opcache.no_cache"                      , "0"   , PHP_INI_SYSTEM, OnUpdateBool,	   accel_directives.no_cache,                      zend_accel_globals, accel_globals)
 #ifdef HAVE_HUGE_CODE_PAGES
 	STD_PHP_INI_BOOLEAN("opcache.huge_code_pages"             , "0"   , PHP_INI_SYSTEM, OnUpdateBool,      accel_directives.huge_code_pages,               zend_accel_globals, accel_globals)
 #endif
@@ -337,6 +338,10 @@ void zend_accel_override_file_functions(void)
 			zend_accel_error(ACCEL_LOG_WARNING, "file_override_enabled has no effect when file_cache_only is set");
 			return;
 		}
+		if (no_cache) {
+			zend_accel_error(ACCEL_LOG_WARNING, "file_override_enabled has no effect when file_cache_only is set");
+			return;
+		}
 		/* override file_exists */
 		if ((old_function = zend_hash_str_find_ptr(CG(function_table), "file_exists", sizeof("file_exists")-1)) != NULL) {
 			orig_file_exists = old_function->internal_function.handler;
@@ -366,7 +371,7 @@ void zend_accel_info(ZEND_MODULE_INFO_FUNC_ARGS)
 {
 	php_info_print_table_start();
 
-	if (ZCG(accelerator_enabled) || file_cache_only) {
+	if ((ZCG(accelerator_enabled) || file_cache_only) && !no_cache) {
 		php_info_print_table_row(2, "Opcode Caching", "Up and Running");
 	} else {
 		php_info_print_table_row(2, "Opcode Caching", "Disabled");
@@ -376,7 +381,7 @@ void zend_accel_info(ZEND_MODULE_INFO_FUNC_ARGS)
 	} else {
 		php_info_print_table_row(2, "Optimization", "Disabled");
 	}
-	if (!file_cache_only) {
+	if (!file_cache_only && !no_cache) {
 		php_info_print_table_row(2, "SHM Cache", "Enabled");
 	} else {
 		php_info_print_table_row(2, "SHM Cache", "Disabled");
@@ -395,7 +400,7 @@ void zend_accel_info(ZEND_MODULE_INFO_FUNC_ARGS)
 #else
 	php_info_print_table_row(2, "JIT", "Not Available");
 #endif
-	if (file_cache_only) {
+	if (file_cache_only || no_cache) {  // TODO test failure mode
 		if (!accel_startup_ok || zps_api_failure_reason) {
 			php_info_print_table_row(2, "Startup Failed", zps_api_failure_reason);
 		} else {
@@ -546,6 +551,10 @@ ZEND_FUNCTION(opcache_get_status)
 		add_assoc_bool(return_value, "file_cache_only", 1);
 		return;
 	}
+	if (no_cache) {
+		add_assoc_bool(return_value, "no_cache", 1);
+		return;
+	}
 
 	add_assoc_bool(return_value, "cache_full", ZSMMG(memory_exhausted));
 	add_assoc_bool(return_value, "restart_pending", ZCSG(restart_pending));
@@ -707,6 +716,7 @@ ZEND_FUNCTION(opcache_get_configuration)
 #if ENABLE_FILE_CACHE_FALLBACK
 	add_assoc_bool(&directives,   "opcache.file_cache_fallback",           ZCG(accel_directives).file_cache_fallback);
 #endif
+	add_assoc_bool(&directives,   "opcache.no_cache",                      ZCG(accel_directives).no_cache);
 
 	add_assoc_long(&directives,   "opcache.file_update_protection",  ZCG(accel_directives).file_update_protection);
 	add_assoc_long(&directives,   "opcache.opt_debug_level",         ZCG(accel_directives).opt_debug_level);