क्या आप सीपीयू उपयोग को .NET प्रक्रिया ऑब्जेक्ट पर सीमित कर सकते हैं?

Question

सी।

सी प्रक्रिया में कुछ घटक भारी स्ट्रंचिंग करते हैं और यदि आप सावधान नहीं हैं तो वास्तव में आपके सीपीयू को हथौड़ा कर सकते हैं।

क्या .NET द्वारा उत्पन्न बाहरी प्रक्रियाओं की सीमा निर्धारित करने का कोई तरीका है?

मैंने ओएस स्तर पर हार्ड मेमोरी सीमा निर्धारित करने पर this artivcle देखा है, क्या सीपीयू के लिए एक समान चीज है?

Answer 1

विंडोज़ में नहीं। हालांकि आप प्रक्रिया प्राथमिकता को कम कर सकते हैं, जिससे समस्या को कम किया जाएगा कि समस्याग्रस्त प्रक्रिया सीपीयू पर निर्धारित की जाएगी और अन्य (संभवतः उच्च प्राथमिकता) अनुप्रयोगों में हस्तक्षेप करेगी। उदाहरण के लिए, http://dotnet-concepts-queries-interviews.blogspot.com/2007/05/how-to-set-process-priority-in-net.html से लिए:

Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal; 

ध्यान रखें, आप कुछ और बॉक्स पर चल रहा है नहीं है, तो आप शायद इस प्रक्रिया को उपलब्ध सीपीयू के सभी उपभोग करने के लिए चाहते हैं।

यदि आप बहु-प्रोसेसर बॉक्स पर हैं, तो कुछ कोर को प्रोसेसिंग सीमित करते हैं और अन्य अनुप्रयोगों के लिए दूसरों को मुक्त करते हैं, तो आप सीपीयू एफ़िनिटी भी सेट कर सकते हैं। आम तौर पर ओएस शेड्यूलिंग एप्लिकेशन थ्रेड का अच्छा काम करता है, इसलिए प्रक्रिया प्राथमिकता को सेट करना बेहतर समग्र परिणाम होने की संभावना है। How Can I Set Processor Affinity in .NET?

Answer 2

मुझे एक ही समस्या थी। मैंने इसे SetInformationJobObject कर्नेल 32 विन एपी और JOBOBJECT_CPU_RATE_CONTROL_INFORMATION संरचना का उपयोग करके हल किया।

मेरी बड़ी समस्या सी # में इस संरचना का प्रतिनिधित्व करना था ("संघ" का उपयोग करता है)। उम्मीद है कि, मुझे इस संरचना का "मोनो" विवरण मिला है।

[StructLayout(LayoutKind.Explicit)] 
//[CLSCompliant(false)] 
struct JOBOBJECT_CPU_RATE_CONTROL_INFORMATION 
{ 
    [FieldOffset(0)] 
    public UInt32 ControlFlags; 
    [FieldOffset(4)] 
    public UInt32 CpuRate; 
    [FieldOffset(4)] 
    public UInt32 Weight; 
} 

सीपीयू सीमा सक्रिय करने के लिए:

ControlFlags = 0x00000001 | 0x00000004; 
CpuRate = percent of max usage * 100 (ex 50 * 100 for a 50% limit) 

नीचे दिए गए नमूना पूरी तरह कार्यात्मक है।

मुझे आशा है कि यह मदद करेगा।

सधन्यवाद

-Thierry-

[DllImport("kernel32.dll", EntryPoint = "CreateJobObjectW", CharSet = CharSet.Unicode)] 
public static extern IntPtr CreateJobObject(SecurityAttributes JobAttributes, string lpName); 

[DllImport("kernel32.dll")] 
[return: MarshalAs(UnmanagedType.Bool)] 
static extern bool AssignProcessToJobObject(IntPtr hJob, IntPtr hProcess); 

[DllImport("kernel32.dll")] 
static extern bool SetInformationJobObject(IntPtr hJob, JOBOBJECTINFOCLASS JobObjectInfoClass, IntPtr lpJobObjectInfo, uint cbJobObjectInfoLength); 

public class SecurityAttributes 
{ 

    public int nLength; 
    public IntPtr pSecurityDescriptor; 
    public bool bInheritHandle; 

    public SecurityAttributes() 
    { 
     this.bInheritHandle = true; 
     this.nLength = 0; 
     this.pSecurityDescriptor = IntPtr.Zero; 
    } 
} 

public enum JOBOBJECTINFOCLASS 
{ 
    JobObjectAssociateCompletionPortInformation = 7, 
    JobObjectBasicLimitInformation = 2, 
    JobObjectBasicUIRestrictions = 4, 
    JobObjectEndOfJobTimeInformation = 6, 
    JobObjectExtendedLimitInformation = 9, 
    JobObjectSecurityLimitInformation = 5, 
    JobObjectCpuRateControlInformation = 15 
} 

[StructLayout(LayoutKind.Explicit)] 
//[CLSCompliant(false)] 
struct JOBOBJECT_CPU_RATE_CONTROL_INFORMATION 
{ 
    [FieldOffset(0)] 
    public UInt32 ControlFlags; 
    [FieldOffset(4)] 
    public UInt32 CpuRate; 
    [FieldOffset(4)] 
    public UInt32 Weight; 
} 

public enum CpuFlags 
{ 
    JOB_OBJECT_CPU_RATE_CONTROL_ENABLE = 0x00000001, 
    JOB_OBJECT_CPU_RATE_CONTROL_WEIGHT_BASED = 0x00000002, 
    JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP = 0x00000004 
} 

/// <summary> 
/// Launch the legacy application with some options set. 
/// </summary> 
static void DoExecuteProgramm() 
{ 
    // prepare the process to execute 
    var startInfo = new ProcessStartInfo(); 
    . . . . . 
    // Start the process 
    var process = Process.Start(startInfo); 

    //Limit the CPU usage to 45% 
    var jobHandle = CreateJobObject(null, null); 
    AssignProcessToJobObject(jobHandle, process.Handle); 
    var cpuLimits = new JOBOBJECT_CPU_RATE_CONTROL_INFORMATION(); 
    cpuLimits.ControlFlags = (UInt32)(CpuFlags.JOB_OBJECT_CPU_RATE_CONTROL_ENABLE | CpuFlags.JOB_OBJECT_CPU_RATE_CONTROL_HARD_CAP); 
    cpuLimits.CpuRate = 45 * 100; // Limit CPu usage to 45% 
    var pointerToJobCpuLimits = Marshal.AllocHGlobal(Marshal.SizeOf(cpuLimits)); 
    Marshal.StructureToPtr(cpuLimits, pointerToJobCpuLimits, false); 
    if (!SetInformationJobObject(jobHandle, JOBOBJECTINFOCLASS.JobObjectCpuRateControlInformation, pointerToJobCpuLimits, (uint)Marshal.SizeOf(cpuLimits))) 
    { 
     Console.WriteLine("Error !"); 
    } 
}