opcache_invalidate - PHP code example

OPcache Functions in PHP

PHP OPcache is a bytecode caching system that increases the performance of your web application. It does so by storing precompiled bytecode which eliminates the need to load and parse the script on each request. This results in significant reductions of the time to load your Website.

OPcache is installed and activated by default with PHP version 5.5+. It replaces the APC caching system that was previously included with PHP. Its functionality is similar to APC, but it is formally endorsed by the PHP developers which is an important indication of stability and a large working community.

One of the most important functions in opcache is opcache_invalidate(). This function clears the opcode cache for a specific script. The script is identified by the path to the file as well as the extension. Invalidation can be forced if the parameter $force is set. The function returns TRUE if the invalidation was successful and FALSE otherwise.

Another important opcache function is opcache_get_status(). This function returns information about the opcode cache’s state including memory usage, hit and miss rates and other useful data. Using this function is an excellent way to monitor your opcode cache to identify bottlenecks and optimize the configuration.

If you run a high volume of scripts that use the opcode cache, it can become full. This can cause the thundering herd effect, where a lot of requests are made simoultaneously generating the same cache entries, and can result in the cache becoming unusable. In this case it is recommended to reset the opcode cache by calling opcache_reset().

opcache_invalidate example

  public static function invalidate($pathname) {
    clearstatcache(TRUE, $pathname);

    // Check if the Zend OPcache is enabled and if so invalidate the file.     if (function_exists('opcache_invalidate')) {
      opcache_invalidate($pathname, TRUE);
    }
  }

}

    /** * Filters whether to invalidate a file from the opcode cache. * * @since 5.5.0 * * @param bool $will_invalidate Whether WordPress will invalidate `$filepath`. Default true. * @param string $filepath The path to the PHP file to invalidate. */
    if ( apply_filters( 'wp_opcache_invalidate_file', true, $filepath ) ) {
        return opcache_invalidate( $filepath, $force );
    }

    return false;
}

/** * Attempts to clear the opcode cache for a directory of files. * * @since 6.2.0 * * @see wp_opcache_invalidate() * @link https://www.php.net/manual/en/function.opcache-invalidate.php * * @global WP_Filesystem_Base $wp_filesystem WordPress filesystem subclass. * * @param string $dir The path to the directory for which the opcode cache is to be cleared. */

if (null !== $metadata) {
            $filesystem->dumpFile($this->getMetaFile(), serialize($metadata));
            try {
                $filesystem->chmod($this->getMetaFile(), $mode, $umask);
            } catch (IOException) {
                // discard chmod failure (some filesystem may not support it)             }
        }

        if (\function_exists('opcache_invalidate') && filter_var(\ini_get('opcache.enable'), \FILTER_VALIDATE_BOOL)) {
            @opcache_invalidate($this->file, true);
        }
    }

    /** * Gets the meta file path. */
    private function getMetaFile(): string
    {
        return $this->file.'.meta';
    }

else {
                // We cannot use a closure here because of https://bugs.php.net/76982                 $value = str_replace('\Symfony\Component\VarExporter\Internal\\', '', $value);
                $value = "namespace Symfony\Component\VarExporter\Internal;\n\nreturn \$getExpiry ? {$expiry} : {$value};";
            }

            $file = $this->files[$key] = $this->getFile($key, true);
            // Since OPcache only compiles files older than the script execution start, set the file's mtime in the past             $ok = $this->write($file, "<?php //{$encodedKey}\n\n{$value}\n", self::$startTime - 10) && $ok;

            if ($allowCompile) {
                @opcache_invalidate($file, true);
                @opcache_compile_file($file);
            }
            unset(self::$valuesCache[$file]);
        }

        if (!$ok && !is_writable($this->directory)) {
            throw new CacheException(sprintf('Cache directory is not writable (%s).', $this->directory));
        }

        return $ok;
    }

elseif (!is_writable($dir)) {
            throw new \RuntimeException(sprintf('Unable to write in the cache directory (%s).', $dir));
        }

        $tmpFile = tempnam($dir, basename($key));
        if (false !== @file_put_contents($tmpFile, $content) && @rename($tmpFile, $key)) {
            @chmod($key, 0666 & ~umask());

            if (self::FORCE_BYTECODE_INVALIDATION == ($this->options & self::FORCE_BYTECODE_INVALIDATION)) {
                // Compile cached file into bytecode cache                 if (\function_exists('opcache_invalidate') && filter_var(ini_get('opcache.enable'), \FILTER_VALIDATE_BOOLEAN)) {
                    @opcache_invalidate($key, true);
                } elseif (\function_exists('apc_compile_file')) {
                    apc_compile_file($key);
                }
            }

            return;
        }

        throw new \RuntimeException(sprintf('Failed to write cache file "%s".', $key));
    }