*
     * @param totalPhysicalMemory total physical memory in bytes
     * @param freePhysicalMemory free physical memory in bytes
     */
    public OsMemoryStatusSnapshot(long totalPhysicalMemory, long freePhysicalMemory) {
        this(
            new DefaultAvailableOsMemoryStatusAspect("physical", totalPhysicalMemory, freePhysicalMemory),

        1 * mockMemoryStatus.physicalMemory >> { new DefaultAvailableOsMemoryStatusAspect("physical", MAX_MEMORY, ONE_GIG) }
        expirationStrategy.onOsMemoryStatus(mockMemoryStatus)

        then:
        expirationStrategy.physicalMemoryThresholdInBytes == LowMemoryDaemonExpirationStrategy.MAX_THRESHOLD_BYTES
    }

    def "daemon should expire when physical memory falls below threshold"() {
        given:

// license that can be found in the LICENSE file.

package runtime

const (
	_VDSO_TH_ALGO_ARM_GENTIM = 1
)

func getCntxct(physical bool) uint32

//go:nosplit
func (th *vdsoTimehands) getTimecounter() (uint32, bool) {
	switch th.algo {
	case _VDSO_TH_ALGO_ARM_GENTIM:
		return getCntxct(th.physical != 0), true
	default:
		return 0, false
	}

 */

package org.gradle.process.internal.health.memory;

/**
 * OS memory status.
 */
public interface OsMemoryStatus {
    /**
     * Get the physical memory information.
     *
     * @return the physical memory information
     */
    OsMemoryStatusAspect.Available getPhysicalMemory();

    /**
     * Get the virtual memory information.
     *

        if (total == -1) {
            throw new UnsupportedOperationException("Unable to retrieve total physical memory from MBean");
        }
        if (free == -1) {
            throw new UnsupportedOperationException("Unable to retrieve free physical memory from MBean");
        }
        return new OsMemoryStatusSnapshot(total, free);
    }

	// for the operating system to use. The amount returned by GlobalMemoryStatusEx
	// is closer in parity with Linux
	// https://www.kernel.org/doc/Documentation/filesystems/proc.txt
	var statex MemoryStatusEx
	statex.Length = uint32(unsafe.Sizeof(statex))
	ret, _, _ := procGlobalMemoryStatusEx.Call(uintptr(unsafe.Pointer(&statex)))

	if ret == 0 {
		return 0, errors.New("unable to read physical memory")
	}

 * limitations under the License.
 */

package org.gradle.nativeplatform;

import org.gradle.api.Incubating;
import org.gradle.api.file.FileCollection;

/**
 * A physical representation of a {@link NativeLibrary} component.
 */
@Incubating
public interface NativeLibraryBinary extends NativeBinary {

    FileCollection getHeaderDirs();

    FileCollection getLinkFiles();

 * limitations under the License.
 */
package org.gradle.platform.base;

import org.gradle.api.Incubating;
import org.gradle.model.ModelMap;

/**
 * A container for project binaries, which represent physical artifacts that can run on a particular platform or runtime.
 */
@Incubating

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.platform.base;

import org.gradle.api.Incubating;

/**
 * A physical binary artifact, which can run on a particular platform or runtime.
 */
@Incubating
public interface Binary {
    /**
     * Returns a human-consumable display name for this binary.
     */

// 2) Reserved - Owned by the runtime, but accessing it would cause a fault.
//               Does not count against the process' memory footprint.
// 3) Prepared - Reserved, intended not to be backed by physical memory (though
//               an OS may implement this lazily). Can transition efficiently to
//               Ready. Accessing memory in such a region is undefined (may