PERFORMANCE_INFORMATION

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct PERFORMANCE_INFORMATION
{
    public uint cb;
    public UIntPtr CommitTotal;
    public UIntPtr CommitLimit;
    public UIntPtr CommitPeak;
    public UIntPtr PhysicalTotal;
    public UIntPtr PhysicalAvailable;
    public UIntPtr SystemCache;
    public UIntPtr KernelTotal;
    public UIntPtr KernelPaged;
    public UIntPtr KernelNonpaged;
    public UIntPtr PageSize;
    public uint HandleCount;
    public uint ProcessCount;
    public uint ThreadCount;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure PERFORMANCE_INFORMATION
    Public cb As UInteger
    Public CommitTotal As UIntPtr
    Public CommitLimit As UIntPtr
    Public CommitPeak As UIntPtr
    Public PhysicalTotal As UIntPtr
    Public PhysicalAvailable As UIntPtr
    Public SystemCache As UIntPtr
    Public KernelTotal As UIntPtr
    Public KernelPaged As UIntPtr
    Public KernelNonpaged As UIntPtr
    Public PageSize As UIntPtr
    Public HandleCount As UInteger
    Public ProcessCount As UInteger
    Public ThreadCount As UInteger
End Structure

import ctypes
from ctypes import wintypes

class PERFORMANCE_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("cb", wintypes.DWORD),
        ("CommitTotal", ctypes.c_size_t),
        ("CommitLimit", ctypes.c_size_t),
        ("CommitPeak", ctypes.c_size_t),
        ("PhysicalTotal", ctypes.c_size_t),
        ("PhysicalAvailable", ctypes.c_size_t),
        ("SystemCache", ctypes.c_size_t),
        ("KernelTotal", ctypes.c_size_t),
        ("KernelPaged", ctypes.c_size_t),
        ("KernelNonpaged", ctypes.c_size_t),
        ("PageSize", ctypes.c_size_t),
        ("HandleCount", wintypes.DWORD),
        ("ProcessCount", wintypes.DWORD),
        ("ThreadCount", wintypes.DWORD),
    ]

#[repr(C)]
pub struct PERFORMANCE_INFORMATION {
    pub cb: u32,
    pub CommitTotal: usize,
    pub CommitLimit: usize,
    pub CommitPeak: usize,
    pub PhysicalTotal: usize,
    pub PhysicalAvailable: usize,
    pub SystemCache: usize,
    pub KernelTotal: usize,
    pub KernelPaged: usize,
    pub KernelNonpaged: usize,
    pub PageSize: usize,
    pub HandleCount: u32,
    pub ProcessCount: u32,
    pub ThreadCount: u32,
}

import "golang.org/x/sys/windows"

type PERFORMANCE_INFORMATION struct {
	cb uint32
	CommitTotal uintptr
	CommitLimit uintptr
	CommitPeak uintptr
	PhysicalTotal uintptr
	PhysicalAvailable uintptr
	SystemCache uintptr
	KernelTotal uintptr
	KernelPaged uintptr
	KernelNonpaged uintptr
	PageSize uintptr
	HandleCount uint32
	ProcessCount uint32
	ThreadCount uint32
}

type
  PERFORMANCE_INFORMATION = record
    cb: DWORD;
    CommitTotal: NativeUInt;
    CommitLimit: NativeUInt;
    CommitPeak: NativeUInt;
    PhysicalTotal: NativeUInt;
    PhysicalAvailable: NativeUInt;
    SystemCache: NativeUInt;
    KernelTotal: NativeUInt;
    KernelPaged: NativeUInt;
    KernelNonpaged: NativeUInt;
    PageSize: NativeUInt;
    HandleCount: DWORD;
    ProcessCount: DWORD;
    ThreadCount: DWORD;
  end;

const PERFORMANCE_INFORMATION = extern struct {
    cb: u32,
    CommitTotal: usize,
    CommitLimit: usize,
    CommitPeak: usize,
    PhysicalTotal: usize,
    PhysicalAvailable: usize,
    SystemCache: usize,
    KernelTotal: usize,
    KernelPaged: usize,
    KernelNonpaged: usize,
    PageSize: usize,
    HandleCount: u32,
    ProcessCount: u32,
    ThreadCount: u32,
};

type
  PERFORMANCE_INFORMATION {.bycopy.} = object
    cb: uint32
    CommitTotal: uint
    CommitLimit: uint
    CommitPeak: uint
    PhysicalTotal: uint
    PhysicalAvailable: uint
    SystemCache: uint
    KernelTotal: uint
    KernelPaged: uint
    KernelNonpaged: uint
    PageSize: uint
    HandleCount: uint32
    ProcessCount: uint32
    ThreadCount: uint32

struct PERFORMANCE_INFORMATION
{
    uint cb;
    size_t CommitTotal;
    size_t CommitLimit;
    size_t CommitPeak;
    size_t PhysicalTotal;
    size_t PhysicalAvailable;
    size_t SystemCache;
    size_t KernelTotal;
    size_t KernelPaged;
    size_t KernelNonpaged;
    size_t PageSize;
    uint HandleCount;
    uint ProcessCount;
    uint ThreadCount;
}