}

// An inlineUnwinder iterates over the stack of inlined calls at a PC by
// decoding the inline table. The last step of iteration is always the frame of
// the physical function, so there's always at least one frame.
//
// This is typically used as:
//
//	for u, uf := newInlineUnwinder(...); uf.valid(); uf = u.next(uf) { ... }
//

This sample shows how to structure a software product that consists of multiple components as a set of connected Gradle builds.
As such, it shows how Gradle is used to model a project's architecture and reflect that in the physical structure of the files that make up the software.
This example is described as part of the link:{userManualPath}/structuring_software_products.html[documentation on this topic].

	// Report Version:  7
	// Analysis Tool:   /Applications/Xcode.app/Contents/Developer/usr/bin/vmmap
	// Analysis Tool Version:  Xcode 14.3 (14E222b)
	//
	// Physical footprint:         1.2G
	// Physical footprint (peak):  1.2G
	// Idle exit:                  untracked
	// ----
	//
	// Virtual Memory Map of process 53799 (gopls)
	// Output report format:  2.4  -64-bit process

 * limitations under the License.
 */

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

import org.gradle.api.Named;
import org.gradle.api.NonNullApi;

/**
 * Memory status information, usually either physical or virtual.
 */
@NonNullApi
public interface OsMemoryStatusAspect extends Named {
    /**
     * Get the name of this category.
     *
     * @return the name of this category
     */
    @Override

//     xla_device_type - The device type that is being targeted.
// Output:
//     Tensorflow Dialect MLIR with Runtime specific ops. All tf_device.cluster
//     ops are removed. Physical devices are assigned to ops instead of virtual
//     devices.
tensorflow::Status RunLowerClusterToRuntimeOpsPassPipeline(
    mlir::ModuleOp module, tsl::DeviceType xla_device_type,

        return memoryManager
    }

    def newMemoryManager() {
        newMemoryManager(osMemoryInfo)
    }

    def "does not attempt to release memory when claiming 0 memory and free physical memory is available"() {
        given:
        osMemoryInfo.freeMemory = MemoryAmount.of('4g').bytes
        def memoryManager = newMemoryManager()

        and:
        def holder = Mock(MemoryHolder)

            KlibMetaFileType,
            FileViewProviderFactory { file, _, manager, _ ->
                K2KotlinNativeMetadataDecompiler().createFileViewProvider(file, manager, physical = true)
            })
        BinaryFileStubBuilders.INSTANCE.addExplicitExtension(KlibMetaFileType, ClassFileStubBuilder())

        ClassFileDecompilers.getInstance().EP_NAME.point.apply {

namespace {

// Parse GPU compute capability from physical device description. If compute
// capability is not found in device description, return a unit attribute.
mlir::Attribute ParseGpuDeviceMetadata(const Device& device,
                                       mlir::Builder* builder) {
  // Parse GPU device compute capability from physical device description.

        }

        computeSpecialModule(containingFile)?.let { return it }

        if (virtualFile == null) {
            throw KotlinExceptionWithAttachments("Cannot find a KtModule for a non-physical file")
                .withPsiAttachment("containingFile", containingFile)
                .withAttachment("contextualModule", contextualModule?.asDebugString())
        }

}

type vdsoTimehands struct {
	algo         uint32
	gen          uint32
	scale        uint64
	offset_count uint32
	counter_mask uint32
	offset       bintime
	boottime     bintime
	physical     uint32
	res          [7]uint32
}

type vdsoTimekeep struct {
	ver       uint32
	enabled   uint32
	current   uint32
	pad_cgo_0 [4]byte
}

const (
	_VDSO_TK_VER_CURR = 0x1