ホーム › System.JobObjects › JOBOBJECT_EXTENDED_LIMIT_INFORMATION

JOBOBJECT_EXTENDED_LIMIT_INFORMATION

構造体

サイズx64: 144 バイト / x86: 112 バイト

サイズ=各フィールドのバイト数(x64/x86 で異なる場合は x64/x86 と併記)。x64/x86 列=フィールドのバイトオフセット(HSPで dupptr / lpoke / wpoke 等に使用)。

フィールド

フィールド	型	サイズ	x64	x86	説明
BasicLimitInformation	JOBOBJECT_BASIC_LIMIT_INFORMATION	64/48	+0	+0	基本制限情報を格納する入れ子構造体。
IoInfo	IO_COUNTERS	48	+64	+48	ジョブのI/Oカウンター情報。予約フィールドとして扱われる。
ProcessMemoryLimit	UINT_PTR	8/4	+112	+96	各プロセスのコミットメモリ上限(バイト)。
JobMemoryLimit	UINT_PTR	8/4	+120	+100	ジョブ全体のコミットメモリ上限(バイト)。
PeakProcessMemoryUsed	UINT_PTR	8/4	+128	+104	単一プロセスのピークコミットメモリ使用量(バイト)。
PeakJobMemoryUsed	UINT_PTR	8/4	+136	+108	ジョブ全体のピークコミットメモリ使用量(バイト)。

各言語での定義

#include <windows.h>

// JOBOBJECT_BASIC_LIMIT_INFORMATION  (x64 64 / x86 48 バイト)
typedef struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
    LONGLONG PerProcessUserTimeLimit;
    LONGLONG PerJobUserTimeLimit;
    JOB_OBJECT_LIMIT LimitFlags;
    UINT_PTR MinimumWorkingSetSize;
    UINT_PTR MaximumWorkingSetSize;
    DWORD ActiveProcessLimit;
    UINT_PTR Affinity;
    DWORD PriorityClass;
    DWORD SchedulingClass;
} JOBOBJECT_BASIC_LIMIT_INFORMATION;

// IO_COUNTERS  (x64 48 / x86 48 バイト)
typedef struct IO_COUNTERS {
    ULONGLONG ReadOperationCount;
    ULONGLONG WriteOperationCount;
    ULONGLONG OtherOperationCount;
    ULONGLONG ReadTransferCount;
    ULONGLONG WriteTransferCount;
    ULONGLONG OtherTransferCount;
} IO_COUNTERS;

// JOBOBJECT_EXTENDED_LIMIT_INFORMATION  (x64 144 / x86 112 バイト)
typedef struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
    JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
    IO_COUNTERS IoInfo;
    UINT_PTR ProcessMemoryLimit;
    UINT_PTR JobMemoryLimit;
    UINT_PTR PeakProcessMemoryUsed;
    UINT_PTR PeakJobMemoryUsed;
} JOBOBJECT_EXTENDED_LIMIT_INFORMATION;

using System;
using System.Runtime.InteropServices;

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
    public long PerProcessUserTimeLimit;
    public long PerJobUserTimeLimit;
    public uint LimitFlags;
    public UIntPtr MinimumWorkingSetSize;
    public UIntPtr MaximumWorkingSetSize;
    public uint ActiveProcessLimit;
    public UIntPtr Affinity;
    public uint PriorityClass;
    public uint SchedulingClass;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct IO_COUNTERS
{
    public ulong ReadOperationCount;
    public ulong WriteOperationCount;
    public ulong OtherOperationCount;
    public ulong ReadTransferCount;
    public ulong WriteTransferCount;
    public ulong OtherTransferCount;
}

[StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
public struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
    public JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
    public IO_COUNTERS IoInfo;
    public UIntPtr ProcessMemoryLimit;
    public UIntPtr JobMemoryLimit;
    public UIntPtr PeakProcessMemoryUsed;
    public UIntPtr PeakJobMemoryUsed;
}

Imports System.Runtime.InteropServices

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure JOBOBJECT_BASIC_LIMIT_INFORMATION
    Public PerProcessUserTimeLimit As Long
    Public PerJobUserTimeLimit As Long
    Public LimitFlags As UInteger
    Public MinimumWorkingSetSize As UIntPtr
    Public MaximumWorkingSetSize As UIntPtr
    Public ActiveProcessLimit As UInteger
    Public Affinity As UIntPtr
    Public PriorityClass As UInteger
    Public SchedulingClass As UInteger
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure IO_COUNTERS
    Public ReadOperationCount As ULong
    Public WriteOperationCount As ULong
    Public OtherOperationCount As ULong
    Public ReadTransferCount As ULong
    Public WriteTransferCount As ULong
    Public OtherTransferCount As ULong
End Structure

<StructLayout(LayoutKind.Sequential, CharSet:=CharSet.Unicode)>
Public Structure JOBOBJECT_EXTENDED_LIMIT_INFORMATION
    Public BasicLimitInformation As JOBOBJECT_BASIC_LIMIT_INFORMATION
    Public IoInfo As IO_COUNTERS
    Public ProcessMemoryLimit As UIntPtr
    Public JobMemoryLimit As UIntPtr
    Public PeakProcessMemoryUsed As UIntPtr
    Public PeakJobMemoryUsed As UIntPtr
End Structure

import ctypes
from ctypes import wintypes

class JOBOBJECT_BASIC_LIMIT_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("PerProcessUserTimeLimit", ctypes.c_longlong),
        ("PerJobUserTimeLimit", ctypes.c_longlong),
        ("LimitFlags", wintypes.DWORD),
        ("MinimumWorkingSetSize", ctypes.c_size_t),
        ("MaximumWorkingSetSize", ctypes.c_size_t),
        ("ActiveProcessLimit", wintypes.DWORD),
        ("Affinity", ctypes.c_size_t),
        ("PriorityClass", wintypes.DWORD),
        ("SchedulingClass", wintypes.DWORD),
    ]

class IO_COUNTERS(ctypes.Structure):
    _fields_ = [
        ("ReadOperationCount", ctypes.c_ulonglong),
        ("WriteOperationCount", ctypes.c_ulonglong),
        ("OtherOperationCount", ctypes.c_ulonglong),
        ("ReadTransferCount", ctypes.c_ulonglong),
        ("WriteTransferCount", ctypes.c_ulonglong),
        ("OtherTransferCount", ctypes.c_ulonglong),
    ]

class JOBOBJECT_EXTENDED_LIMIT_INFORMATION(ctypes.Structure):
    _fields_ = [
        ("BasicLimitInformation", JOBOBJECT_BASIC_LIMIT_INFORMATION),
        ("IoInfo", IO_COUNTERS),
        ("ProcessMemoryLimit", ctypes.c_size_t),
        ("JobMemoryLimit", ctypes.c_size_t),
        ("PeakProcessMemoryUsed", ctypes.c_size_t),
        ("PeakJobMemoryUsed", ctypes.c_size_t),
    ]

#[repr(C)]
pub struct JOBOBJECT_BASIC_LIMIT_INFORMATION {
    pub PerProcessUserTimeLimit: i64,
    pub PerJobUserTimeLimit: i64,
    pub LimitFlags: u32,
    pub MinimumWorkingSetSize: usize,
    pub MaximumWorkingSetSize: usize,
    pub ActiveProcessLimit: u32,
    pub Affinity: usize,
    pub PriorityClass: u32,
    pub SchedulingClass: u32,
}

#[repr(C)]
pub struct IO_COUNTERS {
    pub ReadOperationCount: u64,
    pub WriteOperationCount: u64,
    pub OtherOperationCount: u64,
    pub ReadTransferCount: u64,
    pub WriteTransferCount: u64,
    pub OtherTransferCount: u64,
}

#[repr(C)]
pub struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION {
    pub BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION,
    pub IoInfo: IO_COUNTERS,
    pub ProcessMemoryLimit: usize,
    pub JobMemoryLimit: usize,
    pub PeakProcessMemoryUsed: usize,
    pub PeakJobMemoryUsed: usize,
}

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

type JOBOBJECT_BASIC_LIMIT_INFORMATION struct {
	PerProcessUserTimeLimit int64
	PerJobUserTimeLimit int64
	LimitFlags uint32
	MinimumWorkingSetSize uintptr
	MaximumWorkingSetSize uintptr
	ActiveProcessLimit uint32
	Affinity uintptr
	PriorityClass uint32
	SchedulingClass uint32
}

type IO_COUNTERS struct {
	ReadOperationCount uint64
	WriteOperationCount uint64
	OtherOperationCount uint64
	ReadTransferCount uint64
	WriteTransferCount uint64
	OtherTransferCount uint64
}

type JOBOBJECT_EXTENDED_LIMIT_INFORMATION struct {
	BasicLimitInformation JOBOBJECT_BASIC_LIMIT_INFORMATION
	IoInfo IO_COUNTERS
	ProcessMemoryLimit uintptr
	JobMemoryLimit uintptr
	PeakProcessMemoryUsed uintptr
	PeakJobMemoryUsed uintptr
}

type
  JOBOBJECT_BASIC_LIMIT_INFORMATION = record
    PerProcessUserTimeLimit: Int64;
    PerJobUserTimeLimit: Int64;
    LimitFlags: DWORD;
    MinimumWorkingSetSize: NativeUInt;
    MaximumWorkingSetSize: NativeUInt;
    ActiveProcessLimit: DWORD;
    Affinity: NativeUInt;
    PriorityClass: DWORD;
    SchedulingClass: DWORD;
  end;

  IO_COUNTERS = record
    ReadOperationCount: UInt64;
    WriteOperationCount: UInt64;
    OtherOperationCount: UInt64;
    ReadTransferCount: UInt64;
    WriteTransferCount: UInt64;
    OtherTransferCount: UInt64;
  end;

  JOBOBJECT_EXTENDED_LIMIT_INFORMATION = record
    BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION;
    IoInfo: IO_COUNTERS;
    ProcessMemoryLimit: NativeUInt;
    JobMemoryLimit: NativeUInt;
    PeakProcessMemoryUsed: NativeUInt;
    PeakJobMemoryUsed: NativeUInt;
  end;

const JOBOBJECT_BASIC_LIMIT_INFORMATION = extern struct {
    PerProcessUserTimeLimit: i64,
    PerJobUserTimeLimit: i64,
    LimitFlags: u32,
    MinimumWorkingSetSize: usize,
    MaximumWorkingSetSize: usize,
    ActiveProcessLimit: u32,
    Affinity: usize,
    PriorityClass: u32,
    SchedulingClass: u32,
};

const IO_COUNTERS = extern struct {
    ReadOperationCount: u64,
    WriteOperationCount: u64,
    OtherOperationCount: u64,
    ReadTransferCount: u64,
    WriteTransferCount: u64,
    OtherTransferCount: u64,
};

const JOBOBJECT_EXTENDED_LIMIT_INFORMATION = extern struct {
    BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION,
    IoInfo: IO_COUNTERS,
    ProcessMemoryLimit: usize,
    JobMemoryLimit: usize,
    PeakProcessMemoryUsed: usize,
    PeakJobMemoryUsed: usize,
};

type
  JOBOBJECT_BASIC_LIMIT_INFORMATION {.bycopy.} = object
    PerProcessUserTimeLimit: int64
    PerJobUserTimeLimit: int64
    LimitFlags: uint32
    MinimumWorkingSetSize: uint
    MaximumWorkingSetSize: uint
    ActiveProcessLimit: uint32
    Affinity: uint
    PriorityClass: uint32
    SchedulingClass: uint32

  IO_COUNTERS {.bycopy.} = object
    ReadOperationCount: uint64
    WriteOperationCount: uint64
    OtherOperationCount: uint64
    ReadTransferCount: uint64
    WriteTransferCount: uint64
    OtherTransferCount: uint64

  JOBOBJECT_EXTENDED_LIMIT_INFORMATION {.bycopy.} = object
    BasicLimitInformation: JOBOBJECT_BASIC_LIMIT_INFORMATION
    IoInfo: IO_COUNTERS
    ProcessMemoryLimit: uint
    JobMemoryLimit: uint
    PeakProcessMemoryUsed: uint
    PeakJobMemoryUsed: uint

struct JOBOBJECT_BASIC_LIMIT_INFORMATION
{
    long PerProcessUserTimeLimit;
    long PerJobUserTimeLimit;
    uint LimitFlags;
    size_t MinimumWorkingSetSize;
    size_t MaximumWorkingSetSize;
    uint ActiveProcessLimit;
    size_t Affinity;
    uint PriorityClass;
    uint SchedulingClass;
}

struct IO_COUNTERS
{
    ulong ReadOperationCount;
    ulong WriteOperationCount;
    ulong OtherOperationCount;
    ulong ReadTransferCount;
    ulong WriteTransferCount;
    ulong OtherTransferCount;
}

struct JOBOBJECT_EXTENDED_LIMIT_INFORMATION
{
    JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation;
    IO_COUNTERS IoInfo;
    size_t ProcessMemoryLimit;
    size_t JobMemoryLimit;
    size_t PeakProcessMemoryUsed;
    size_t PeakJobMemoryUsed;
}

HSP用定義

HSP3.7/3.8 は構造体機能が無いため4byte整数配列(dim)+peek/poke で操作(32/64bitでサイズ・位置が異なる場合はタブで分割)。IronHSP は NSTRUCT(#defstruct/stdim/->)で32/64bit共通。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x86 レイアウト)
; JOBOBJECT_EXTENDED_LIMIT_INFORMATION サイズ: 112 バイト(x86)
dim st, 28    ; 4byte整数×28(構造体サイズ 112 / 4 切り上げ)
; BasicLimitInformation : JOBOBJECT_BASIC_LIMIT_INFORMATION (+0, 48byte)  varptr(st)+0 を基点に操作(48byte:入れ子/配列)
; IoInfo : IO_COUNTERS (+48, 48byte)  varptr(st)+48 を基点に操作(48byte:入れ子/配列)
; ProcessMemoryLimit : UINT_PTR (+96, 4byte)  st.24 = 値  /  値 = st.24   (lpoke/lpeek も可)
; JobMemoryLimit : UINT_PTR (+100, 4byte)  st.25 = 値  /  値 = st.25   (lpoke/lpeek も可)
; PeakProcessMemoryUsed : UINT_PTR (+104, 4byte)  st.26 = 値  /  値 = st.26   (lpoke/lpeek も可)
; PeakJobMemoryUsed : UINT_PTR (+108, 4byte)  st.27 = 値  /  値 = st.27   (lpoke/lpeek も可)
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; HSP3.7/3.8 は構造体機能が無いため、4byte整数の配列変数で操作します。(x64 レイアウト)
; JOBOBJECT_EXTENDED_LIMIT_INFORMATION サイズ: 144 バイト(x64)
dim st, 36    ; 4byte整数×36(構造体サイズ 144 / 4 切り上げ)
; BasicLimitInformation : JOBOBJECT_BASIC_LIMIT_INFORMATION (+0, 64byte)  varptr(st)+0 を基点に操作(64byte:入れ子/配列)
; IoInfo : IO_COUNTERS (+64, 48byte)  varptr(st)+64 を基点に操作(48byte:入れ子/配列)
; ProcessMemoryLimit : UINT_PTR (+112, 8byte)  qpoke st,112,値 / qpeek(st,112)  ※IronHSPのみ。3.7/3.8は lpoke st,112,下位 : lpoke st,116,上位
; JobMemoryLimit : UINT_PTR (+120, 8byte)  qpoke st,120,値 / qpeek(st,120)  ※IronHSPのみ。3.7/3.8は lpoke st,120,下位 : lpoke st,124,上位
; PeakProcessMemoryUsed : UINT_PTR (+128, 8byte)  qpoke st,128,値 / qpeek(st,128)  ※IronHSPのみ。3.7/3.8は lpoke st,128,下位 : lpoke st,132,上位
; PeakJobMemoryUsed : UINT_PTR (+136, 8byte)  qpoke st,136,値 / qpeek(st,136)  ※IronHSPのみ。3.7/3.8は lpoke st,136,下位 : lpoke st,140,上位
; ※4byte境界の整数は添字 st.N(N=オフセット/4)で読み書き可。それ以外は peek/poke 系を使用。

; IronHSP は NSTRUCT(構造体)をサポート。32bit/64bit どちらでも同じコードで動作します。
; ※GUID・入れ子構造体はデフォルト型でないため、依存する #defstruct を先に定義(下記に同梱)。
#defstruct global JOBOBJECT_BASIC_LIMIT_INFORMATION
    #field int64 PerProcessUserTimeLimit
    #field int64 PerJobUserTimeLimit
    #field int LimitFlags
    #field intptr MinimumWorkingSetSize
    #field intptr MaximumWorkingSetSize
    #field int ActiveProcessLimit
    #field intptr Affinity
    #field int PriorityClass
    #field int SchedulingClass
#endstruct

#defstruct global IO_COUNTERS
    #field int64 ReadOperationCount
    #field int64 WriteOperationCount
    #field int64 OtherOperationCount
    #field int64 ReadTransferCount
    #field int64 WriteTransferCount
    #field int64 OtherTransferCount
#endstruct

#defstruct global JOBOBJECT_EXTENDED_LIMIT_INFORMATION
    #field JOBOBJECT_BASIC_LIMIT_INFORMATION BasicLimitInformation
    #field IO_COUNTERS IoInfo
    #field intptr ProcessMemoryLimit
    #field intptr JobMemoryLimit
    #field intptr PeakProcessMemoryUsed
    #field intptr PeakJobMemoryUsed
#endstruct

stdim st, JOBOBJECT_EXTENDED_LIMIT_INFORMATION        ; NSTRUCT 変数を確保
st->ProcessMemoryLimit = 100
mes "ProcessMemoryLimit=" + st->ProcessMemoryLimit

JOBOBJECT_EXTENDED_LIMIT_INFORMATION

フィールド

各言語での定義

HSP用 定義

HSP用定義