WindowCacheConfig.java

/*
 * Copyright (C) 2009, Google Inc. and others
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Distribution License v. 1.0 which is available at
 * https://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: BSD-3-Clause
 */

package org.eclipse.jgit.storage.file;

import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_CORE_SECTION;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_DELTA_BASE_CACHE_LIMIT;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PACKED_GIT_LIMIT;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PACKED_GIT_MMAP;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PACKED_GIT_OPENFILES;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PACKED_GIT_WINDOWSIZE;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_STREAM_FILE_TRESHOLD;
import static org.eclipse.jgit.lib.ConfigConstants.CONFIG_KEY_PACKED_GIT_USE_STRONGREFS;

import org.eclipse.jgit.internal.storage.file.WindowCache;
import org.eclipse.jgit.lib.Config;
import org.eclipse.jgit.storage.pack.PackConfig;

/**
 * Configuration parameters for JVM-wide buffer cache used by JGit.
 */
public class WindowCacheConfig {
    /** 1024 (number of bytes in one kibibyte/kilobyte) */
    public static final int KB = 1024;

    /** 1024 {@link #KB} (number of bytes in one mebibyte/megabyte) */
    public static final int MB = 1024 * KB;

    private int packedGitOpenFiles;

    private long packedGitLimit;

    private boolean useStrongRefs;

    private int packedGitWindowSize;

    private boolean packedGitMMAP;

    private int deltaBaseCacheLimit;

    private int streamFileThreshold;

    private boolean exposeStats;

    /**
     * Create a default configuration.
     */
    public WindowCacheConfig() {
        packedGitOpenFiles = 128;
        packedGitLimit = 10 * MB;
        useStrongRefs = false;
        packedGitWindowSize = 8 * KB;
        packedGitMMAP = false;
        deltaBaseCacheLimit = 10 * MB;
        streamFileThreshold = PackConfig.DEFAULT_BIG_FILE_THRESHOLD;
        exposeStats = true;
    }

    /**
     * Get maximum number of streams to open at a time.
     *
     * @return maximum number of streams to open at a time. Open packs count
     *         against the process limits. <b>Default is 128.</b>
     */
    public int getPackedGitOpenFiles() {
        return packedGitOpenFiles;
    }

    /**
     * Set maximum number of streams to open at a time.
     *
     * @param fdLimit
     *            maximum number of streams to open at a time. Open packs count
     *            against the process limits
     */
    public void setPackedGitOpenFiles(int fdLimit) {
        packedGitOpenFiles = fdLimit;
    }

    /**
     * Get maximum number bytes of heap memory to dedicate to caching pack file
     * data.
     *
     * @return maximum number bytes of heap memory to dedicate to caching pack
     *         file data. <b>Default is 10 MB.</b>
     */
    public long getPackedGitLimit() {
        return packedGitLimit;
    }

    /**
     * Set maximum number bytes of heap memory to dedicate to caching pack file
     * data.
     *
     * @param newLimit
     *            maximum number bytes of heap memory to dedicate to caching
     *            pack file data.
     */
    public void setPackedGitLimit(long newLimit) {
        packedGitLimit = newLimit;
    }

    /**
     * Get whether the window cache should use strong references or
     * SoftReferences
     *
     * @return {@code true} if the window cache should use strong references,
     *         otherwise it will use {@link java.lang.ref.SoftReference}s
     * @since 5.1.13
     */
    public boolean isPackedGitUseStrongRefs() {
        return useStrongRefs;
    }

    /**
     * Set if the cache should use strong refs or soft refs
     *
     * @param useStrongRefs
     *            if @{code true} the cache strongly references cache pages
     *            otherwise it uses {@link java.lang.ref.SoftReference}s which
     *            can be evicted by the Java gc if heap is almost full
     * @since 5.1.13
     */
    public void setPackedGitUseStrongRefs(boolean useStrongRefs) {
        this.useStrongRefs = useStrongRefs;
    }

    /**
     * Get size in bytes of a single window mapped or read in from the pack
     * file.
     *
     * @return size in bytes of a single window mapped or read in from the pack
     *         file. <b>Default is 8 KB.</b>
     */
    public int getPackedGitWindowSize() {
        return packedGitWindowSize;
    }

    /**
     * Set size in bytes of a single window read in from the pack file.
     *
     * @param newSize
     *            size in bytes of a single window read in from the pack file.
     */
    public void setPackedGitWindowSize(int newSize) {
        packedGitWindowSize = newSize;
    }

    /**
     * Whether to use Java NIO virtual memory mapping for windows
     *
     * @return {@code true} enables use of Java NIO virtual memory mapping for
     *         windows; false reads entire window into a byte[] with standard
     *         read calls. <b>Default false.</b>
     */
    public boolean isPackedGitMMAP() {
        return packedGitMMAP;
    }

    /**
     * Set whether to enable use of Java NIO virtual memory mapping for windows
     *
     * @param usemmap
     *            {@code true} enables use of Java NIO virtual memory mapping
     *            for windows; false reads entire window into a byte[] with
     *            standard read calls.
     */
    public void setPackedGitMMAP(boolean usemmap) {
        packedGitMMAP = usemmap;
    }

    /**
     * Get maximum number of bytes to cache in delta base cache for inflated,
     * recently accessed objects, without delta chains.
     *
     * @return maximum number of bytes to cache in delta base cache for
     *         inflated, recently accessed objects, without delta chains.
     *         <b>Default 10 MB.</b>
     */
    public int getDeltaBaseCacheLimit() {
        return deltaBaseCacheLimit;
    }

    /**
     * Set maximum number of bytes to cache in delta base cache for inflated,
     * recently accessed objects, without delta chains.
     *
     * @param newLimit
     *            maximum number of bytes to cache in delta base cache for
     *            inflated, recently accessed objects, without delta chains.
     */
    public void setDeltaBaseCacheLimit(int newLimit) {
        deltaBaseCacheLimit = newLimit;
    }

    /**
     * Get the size threshold beyond which objects must be streamed.
     *
     * @return the size threshold beyond which objects must be streamed.
     */
    public int getStreamFileThreshold() {
        return streamFileThreshold;
    }

    /**
     * Set new byte limit for objects that must be streamed.
     *
     * @param newLimit
     *            new byte limit for objects that must be streamed. Objects
     *            smaller than this size can be obtained as a contiguous byte
     *            array, while objects bigger than this size require using an
     *            {@link org.eclipse.jgit.lib.ObjectStream}.
     */
    public void setStreamFileThreshold(int newLimit) {
        streamFileThreshold = newLimit;
    }

    /**
     * Tell whether the statistics JMX bean should be automatically registered.
     * <p>
     * Registration of that bean via JMX is additionally subject to a boolean
     * JGit-specific user config "jmx.WindowCacheStats". The bean will be
     * registered only if this user config is {@code true} <em>and</em>
     * {@code getExposeStatsViaJmx() == true}.
     * </p>
     * <p>
     * By default, this returns {@code true} unless changed via
     * {@link #setExposeStatsViaJmx(boolean)}.
     *
     * @return whether to expose WindowCacheStats statistics via JMX upon
     *         {@link #install()}
     * @since 5.8
     */
    public boolean getExposeStatsViaJmx() {
        return exposeStats;
    }

    /**
     * Defines whether the statistics JMX MBean should be automatically set up.
     * (By default {@code true}.) If set to {@code false}, the JMX monitoring
     * bean is not registered.
     *
     * @param expose
     *            whether to register the JMX Bean
     * @since 5.8
     */
    public void setExposeStatsViaJmx(boolean expose) {
        exposeStats = expose;
    }

    /**
     * Update properties by setting fields from the configuration.
     * <p>
     * If a property is not defined in the configuration, then it is left
     * unmodified.
     *
     * @param rc
     *            configuration to read properties from.
     * @return {@code this}.
     * @since 3.0
     */
    public WindowCacheConfig fromConfig(Config rc) {
        setPackedGitUseStrongRefs(rc.getBoolean(CONFIG_CORE_SECTION,
                CONFIG_KEY_PACKED_GIT_USE_STRONGREFS,
                isPackedGitUseStrongRefs()));
        setPackedGitOpenFiles(rc.getInt(CONFIG_CORE_SECTION, null,
                CONFIG_KEY_PACKED_GIT_OPENFILES, getPackedGitOpenFiles()));
        setPackedGitLimit(rc.getLong(CONFIG_CORE_SECTION, null,
                CONFIG_KEY_PACKED_GIT_LIMIT, getPackedGitLimit()));
        setPackedGitWindowSize(rc.getInt(CONFIG_CORE_SECTION, null,
                CONFIG_KEY_PACKED_GIT_WINDOWSIZE, getPackedGitWindowSize()));
        setPackedGitMMAP(rc.getBoolean(CONFIG_CORE_SECTION, null,
                CONFIG_KEY_PACKED_GIT_MMAP, isPackedGitMMAP()));
        setDeltaBaseCacheLimit(rc.getInt(CONFIG_CORE_SECTION, null,
                CONFIG_KEY_DELTA_BASE_CACHE_LIMIT, getDeltaBaseCacheLimit()));

        long maxMem = Runtime.getRuntime().maxMemory();
        long sft = rc.getLong(CONFIG_CORE_SECTION, null,
                CONFIG_KEY_STREAM_FILE_TRESHOLD, getStreamFileThreshold());
        sft = Math.min(sft, maxMem / 4); // don't use more than 1/4 of the heap
        sft = Math.min(sft, Integer.MAX_VALUE); // cannot exceed array length
        setStreamFileThreshold((int) sft);
        return this;
    }

    /**
     * Install this configuration as the live settings.
     * <p>
     * The new configuration is applied immediately. If the new limits are
     * smaller than what is currently cached, older entries will be purged
     * as soon as possible to allow the cache to meet the new limit.
     *
     * @since 3.0
     */
    @SuppressWarnings("deprecation")
    public void install() {
        WindowCache.reconfigure(this);
    }
}