Windows Display driver/manager??

**Bitnugger**

Zitat von Musashi

Ich wollte mit meinem Beitrag #18 nur darauf hinweisen, nichts beanstanden .

Selbstverständlich...

Ich habe dies aber nun als Anlass genommen und das Script in Post #14 so umgeschrieben, dass es jetzt auch auf Windows XP und älteren AutoIt-Versionen (>= 3.3.14.0) laufen sollte.

Als Wert für $g_iNumberOfEnabledCore wird dann einfach -1 übergeben...

$aWMI[3] = @OSVersion = 'WIN_10' ? $objItem.NumberOfEnabledCore : -1

und anstelle...

#include <WinAPIProc.au3> ; Windows 10

nun mit...

#include <WinAPI.au3> ; Windows XP to Windows 8.1

...und alle sind zufrieden.

Ovik

So, hatte nun endlich Zeit, den Code von Bitnugger einmal durchzutesten und bin auf das einfache Problem gestossen, dass ich logische Prozessoren >32 nicht setzen kann. Ich habe mit dem 18 Core und Hyperthreading 36 ausgewiesene logische Prozessoren. Alles bis $iLogicalProcessor32 (die ich vorher entsprechend definiert habe) funktioniert.

Weiss jemand, wie ich die Maske setzen muss, um die anderen Prozessoren zu setzen? Sorry, wenn ich danach so doof nachfrage, aber die bit-weisen operationen sind haben sich mir noch nicht erschlossen...

**Bitnugger**

Zitat von Ovik

So, hatte nun endlich Zeit, den Code von Bitnugger einmal durchzutesten und bin auf das einfache Problem gestossen, dass ich logische Prozessoren >32 nicht setzen kann.

Dann hat jeder deiner 18 Cores halt nur zwei logische Prozessoren... das ist aber kein Problem, sondern Fakt!

Zitat von Ovik

Ich habe mit dem 18 Core und Hyperthreading 36 ausgewiesene logische Prozessoren.

Was hat Hyperthreading damit zu tun?

Zitat von Ovik

Weiss jemand, wie ich die Maske setzen muss, um die anderen Prozessoren zu setzen?

Die Funktion _GetProcessors() liefert dir doch u.A. die Anzahl der vorhandenen/verfügbaren logischen Prozessoren... und natürlich kannst du nur diese der Mask hinzufügen.

Zitat von Ovik

die bit-weisen operationen sind haben sich mir noch nicht erschlossen...

Code

In der Mask wird für jeden Prozessor ein Bit an entsprechender Stelle gesetzt... wenn du 32 logische Prozessoren hast, brauchst du ergo auch 32 Bits.

Hier die Bits... ganz rechts ist Bit 0 (2^0), ganz links ist Bit 31 (2^31)... (von 0 bis 31 sind 32)
                           76543210
10000000 00000000 00000000 10000001
^                          ^      ^ ... $iLogicalProcessor01 (Bit 0 = 2^0 = Dec 1 = Hex 0x00000001)
^                          ^ ... $iLogicalProcessor08 (Bit 7 = 2^7 = Dec 128 = Hex 0x00000080)
^ ... $iLogicalProcessor32 (Bit 31 = 2^31 = Dec 2147483648 = Hex 0x80000000)

Will ich nun diese drei Prozessoren benutzen, muss ich sie in die Mask eintragen...
$iMask = BitOr(2^0, 2^7, 2^31)                     ; --> 0x80000081
$iMask = BitOr(1, 128, 2147483648)                 ; --> 0x80000081
$iMask = BitOr(0x00000001, 0x00000080, 0x80000000) ; --> 0x80000081

In unserem Fall könnten die Werte auch einfach addiert werden.
$iMask = 2^0 + 2^7 + 2^31                          ; --> 0x80000081
$iMask = 1 + 128 + 2147483648                      ; --> 0x80000081
$iMask = 0x00000001 + 0x00000080 + 0x80000000      ; --> 0x80000081

Das funktioniert aber nur, wenn durch die zu addierenden Werte ein Bit nur einmalig auf 1 gesetzt wird, andernfalls führt es zu anderen/falschen Ergebnissen.
Hier ein Beispiel:
$iMask = BitOR(1, 2, 4)  ; --> 0x00000007 <-- 1 = Bit 0, 2 = Bit 1, 4 = Bit 2
$iMask = 1 + 2 + 4       ; --> 0x00000007 <-- OK!
$iMask = BitOR(1, 2, 48) ; --> 0x00000033 <-- 1 = Bit 0, 2 = Bit 1, 48 = Bit 4 (16) und Bit 5 (32)
$iMask = 1 + 2 + 48      ; --> 0x00000033 <-- OK!
$iMask = BitOR(1, 2, 3)  ; --> 0x00000003 <-- 1 = Bit 0, 2 = Bit 1, 3 = Bit 0 und Bit 1
$iMask = 1 + 2 + 3       ; --> 0x00000006 <-- Fehler!

Alles anzeigen

**Bitnugger**

Hier noch mal das Script aus Post #14, ein wenig erweitert und mit zusätzlichen Infos:

C

;-- TIME_STAMP   2018-12-19 00:23:30   v 0.1

#AutoIt3Wrapper_AU3Check_Parameters=-q -d -w 1 -w 2 -w 3 -w- 4 -w 5 -w 6 -w- 7

#Region ;************ Includes ************
#include <ProcessConstants.au3>
#include <Array.au3>
#include <WinAPI.au3> ; Windows XP to Windows 8.1
;~ #include <WinAPIProc.au3> ; Windows 10
#EndRegion ;************ Includes ************

ConsoleWrite('> @AutoItVersion = ' & @AutoItVersion & '   @AutoItPID = ' & @AutoItPID & @CRLF & @CRLF)

Global Const $wbemFlagReturnImmediately = 0x10, $wbemFlagForwardOnly = 0x20

;~ ConsoleWrite('CurrentThread = ' & _WinAPI_GetCurrentThread() & @CRLF)

Global $aLogicalProcessors[0], $g_aDefaultAffinityMasks, $g_iNumberOfCores, $g_iNumberOfEnabledCore, $g_iNumberOfProcessors, $g_iNumberOfLogicalProcessors ; EnvGet('NUMBER_OF_PROCESSORS')

_Example()

Func _Example()
    Local $aProcessors = _GetProcessors()
    $g_iNumberOfProcessors        = $aProcessors[0]
    $g_iNumberOfLogicalProcessors = $aProcessors[1]
    $g_iNumberOfCores             = $aProcessors[2]
    $g_iNumberOfEnabledCore       = $aProcessors[3]
    ConsoleWrite('> $g_iNumberOfProcessors        = ' & $g_iNumberOfProcessors & @CRLF)
    ConsoleWrite('> $g_iNumberOfLogicalProcessors = ' & $g_iNumberOfLogicalProcessors & @CRLF)
    ConsoleWrite('> $g_iNumberOfCores             = ' & $g_iNumberOfCores & @CRLF)
    ConsoleWrite('> $g_iNumberOfEnabledCore       = ' & $g_iNumberOfEnabledCore & @CRLF & @CRLF)

    If $g_iNumberOfLogicalProcessors Then
            ReDim $aLogicalProcessors[$g_iNumberOfLogicalProcessors]
        For $i = 0 To $g_iNumberOfLogicalProcessors -1 Step 1
            $aLogicalProcessors[$i] = '0x' & Hex(Int(2^$i), 8) ; Hex(2^$i, 8) geht nicht, weil Hex(2^0) fälschlicherweise 0x3FF0000000000000 ist, und nicht 0x0000000000000001!
            ConsoleWrite(StringFormat('$aLogicalProcessors[%2i] = %8s  BitMask --> %s\r\n', $i, $aLogicalProcessors[$i], _UsedLogicalProcessorsToBinaryString($g_iNumberOfLogicalProcessors, $aLogicalProcessors[$i])))
        Next
        ConsoleWrite(@CRLF)
    EndIf
;~     _ArrayDisplay($aLogicalProcessors, '$aLogicalProcessors')
;~     Exit

    $g_aDefaultAffinityMasks = _GetProcessAffinityMasks(@AutoItPID)

    If UBound($aLogicalProcessors) >= 2 Then
        _SetProcessAffinityMask(@AutoItPID, $aLogicalProcessors[0])
        _SetProcessAffinityMask(@AutoItPID, $aLogicalProcessors[1])
    EndIf
    If UBound($aLogicalProcessors) >=  4 Then _SetProcessAffinityMask(@AutoItPID, $aLogicalProcessors[3])
    If UBound($aLogicalProcessors) >=  6 Then _SetProcessAffinityMask(@AutoItPID, BitOR($aLogicalProcessors[4], $aLogicalProcessors[5]))
    If UBound($aLogicalProcessors) >=  8 Then _SetProcessAffinityMask(@AutoItPID, BitOR($aLogicalProcessors[4], $aLogicalProcessors[7]))
    If UBound($aLogicalProcessors) >= 16 Then _SetProcessAffinityMask(@AutoItPID, BitOR($aLogicalProcessors[11], $aLogicalProcessors[12], $aLogicalProcessors[15]))
    If UBound($aLogicalProcessors) >= 32 Then _SetProcessAffinityMask(@AutoItPID, BitOR($aLogicalProcessors[11], $aLogicalProcessors[12], $aLogicalProcessors[31]))

    ; Restore ProcessAffinityMask to default
    If $g_aDefaultAffinityMasks[0] Then _SetProcessAffinityMask(@AutoItPID, $g_aDefaultAffinityMasks[1])
EndFunc

Func _GetProcessAffinityMasks($iPID)
    Local $hProcess = _WinAPI_OpenProcess($PROCESS_ALL_ACCESS, 0, $iPID, True) ; Returns a handle of an existing process object
    Local $aAffinityMask = _WinAPI_GetProcessAffinityMask($hProcess)
    ConsoleWrite('- Default AffinityMask' & @CRLF)
    _PrintProcessInfo($hProcess)
    _WinAPI_CloseHandle($hProcess) ; Closes an open object handle
    Return $aAffinityMask
EndFunc   ;==>_GetProcessAffinityMasks

Func _SetProcessAffinityMask($iPID, $iMask)
    If $iMask < 1 Or $iMask > 2 ^ $g_iNumberOfLogicalProcessors - 1 Then
        ConsoleWrite('! $iMask (' & $iMask & ') ist zu ' & ($iMask < 1 ? 'klein' : 'gross') & '! (1 to ' & 2 ^ $g_iNumberOfLogicalProcessors - 1 & ' for ' & $g_iNumberOfLogicalProcessors & ' Logical Processors)' & @CRLF & @CRLF)
        Return False
    EndIf

    Local $hProcess, $iSetMask = 0
    $hProcess = _WinAPI_OpenProcess($PROCESS_ALL_ACCESS, 0, $iPID, True) ; Returns a handle of an existing process object
    If IsPtr($hProcess) Then
        $iSetMask = _WinAPI_SetProcessAffinityMask($hProcess, $iMask) ; Sets a processor affinity mask for the threads of a specified process
        ConsoleWrite('- New AffinityMask ($iMask = 0x' & Hex($iMask, 8) & ')' & @CRLF)
        _PrintProcessInfo($hProcess)
        _WinAPI_CloseHandle($hProcess) ; Closes an open object handle
    EndIf
    Return $iSetMask
EndFunc   ;==>_SetProcessAffinityMask

Func _PrintProcessInfo($hProcess)
    Local $aAffinityMask = _WinAPI_GetProcessAffinityMask($hProcess) ; Obtains the affinity masks for the process and the system
    If UBound($aAffinityMask) Then
        ConsoleWrite('> $aAffinityMask[0]    = ' & $aAffinityMask[0] & @TAB & @TAB & 'True on success, otherwise False' & @CRLF)
        ConsoleWrite('> $aAffinityMask[1]    = 0x' & Hex($aAffinityMask[1], 8) & @TAB & 'Process affinity mask' & @TAB & @TAB & 'BitMask --> ' & _UsedLogicalProcessorsToBinaryString($g_iNumberOfLogicalProcessors, $aAffinityMask[1]) & @CRLF)
        ConsoleWrite('> $aAffinityMask[2]    = 0x' & Hex($aAffinityMask[2], 8) & @TAB & 'System affinity mask'  & @TAB & @TAB & 'BitMask --> ' & _UsedLogicalProcessorsToBinaryString($g_iNumberOfLogicalProcessors, $aAffinityMask[2]) & @CRLF)
        Local $iUsedProcessorNumber = DllCall('Kernel32.dll', 'dword', 'GetCurrentProcessorNumber')[0]
        ConsoleWrite('+ Used ProcessorNumber = ' & $iUsedProcessorNumber & @TAB & @TAB & '$aLogicalProcessors['&$iUsedProcessorNumber&'] --> ' & $aLogicalProcessors[$iUsedProcessorNumber] & @CRLF & @CRLF)
    EndIf
EndFunc   ;==>_PrintProcessInfo

;~ >wmic CPU GET /FORMAT:List|find "NumberOf"
;~ NumberOfCores=2
;~ NumberOfLogicalProcessors=2
;
;~ >wmic COMPUTERSYSTEM GET /FORMAT:List|find "NumberOf"
;~ NumberOfLogicalProcessors=2
;~ NumberOfProcessors=1
Func _GetProcessors()
    Local $aWMI[4], $objWMIService = ObjGet("winmgmts:\\" & @ComputerName & "\"), $oColItems, $aClasses = ['Win32_ComputerSystem', 'Win32_Processor']

    For $i = 0 To UBound($aClasses) -1 Step 1
        $oColItems = $objWMIService.ExecQuery("SELECT * FROM " & $aClasses[$i], "WQL", $wbemFlagReturnImmediately + $wbemFlagForwardOnly)
        If IsObj($oColItems) then
            For $objItem In $oColItems
                Switch $aClasses[$i]
                    Case 'Win32_ComputerSystem'
                            $aWMI[0] = $objItem.NumberOfProcessors
                    Case 'Win32_Processor'
                            $aWMI[1] = $objItem.NumberOfLogicalProcessors
                            $aWMI[2] = $objItem.NumberOfCores
                            $aWMI[3] = @OSVersion = 'WIN_10' ? $objItem.NumberOfEnabledCore : -1
                EndSwitch
            Next
        Else
            Msgbox(16, "_GetProcessors", "No WMI Objects found for Class: " & $aClasses[$i])
        Endif
    Next
    Return $aWMI
EndFunc   ;==>_GetProcessors

Func _UsedLogicalProcessorsToBinaryString($iNumberOfLogicalProcessors, $iUsedLogicalProcessors)
    Local $bAffinityMask
    For $i = $iNumberOfLogicalProcessors -1 To 0 Step -1
        $bAffinityMask &= BitAND($iUsedLogicalProcessors, 2^$i) ? '1' : '0'
    Next
    Return SetExtended(Int($bAffinityMask), $bAffinityMask)
EndFunc

Alles anzeigen

Ovik

Vielen Dank, Bignugger für die super Erklärung. Echt genial gute Darstellung!!

Das Script hab ich laufen lassen. Mir ist nun auch klar, warum die Prozessoren 32-35 nicht ansprechbar sind (Maske hat ja nur 32 Bits). Aber wie verbinde ich denn nun einen Prozess mit den Prozessoren 32-35? Im Process Explorer kann das ja manuell machen. Aber wie machen die das??? Übersehe ich etwas?

Hier noch der Script-Output:

Code

> @AutoItVersion = 3.3.14.4   @AutoItPID = 7652

> $g_iNumberOfProcessors        = 1
> $g_iNumberOfLogicalProcessors = 36
> $g_iNumberOfCores             = 18
> $g_iNumberOfEnabledCore       = 18

$aLogicalProcessors[ 0] = 0x00000001  BitMask --> 000000000000000000000000000000000001
$aLogicalProcessors[ 1] = 0x00000002  BitMask --> 000000000000000000000000000000000010
$aLogicalProcessors[ 2] = 0x00000004  BitMask --> 000000000000000000000000000000000100
$aLogicalProcessors[ 3] = 0x00000008  BitMask --> 000000000000000000000000000000001000
$aLogicalProcessors[ 4] = 0x00000010  BitMask --> 000000000000000000000000000000010000
$aLogicalProcessors[ 5] = 0x00000020  BitMask --> 000000000000000000000000000000100000
$aLogicalProcessors[ 6] = 0x00000040  BitMask --> 000000000000000000000000000001000000
$aLogicalProcessors[ 7] = 0x00000080  BitMask --> 000000000000000000000000000010000000
$aLogicalProcessors[ 8] = 0x00000100  BitMask --> 000000000000000000000000000100000000
$aLogicalProcessors[ 9] = 0x00000200  BitMask --> 000000000000000000000000001000000000
$aLogicalProcessors[10] = 0x00000400  BitMask --> 000000000000000000000000010000000000
$aLogicalProcessors[11] = 0x00000800  BitMask --> 000000000000000000000000100000000000
$aLogicalProcessors[12] = 0x00001000  BitMask --> 000000000000000000000001000000000000
$aLogicalProcessors[13] = 0x00002000  BitMask --> 000000000000000000000010000000000000
$aLogicalProcessors[14] = 0x00004000  BitMask --> 000000000000000000000100000000000000
$aLogicalProcessors[15] = 0x00008000  BitMask --> 000000000000000000001000000000000000
$aLogicalProcessors[16] = 0x00010000  BitMask --> 000000000000000000010000000000000000
$aLogicalProcessors[17] = 0x00020000  BitMask --> 000000000000000000100000000000000000
$aLogicalProcessors[18] = 0x00040000  BitMask --> 000000000000000001000000000000000000
$aLogicalProcessors[19] = 0x00080000  BitMask --> 000000000000000010000000000000000000
$aLogicalProcessors[20] = 0x00100000  BitMask --> 000000000000000100000000000000000000
$aLogicalProcessors[21] = 0x00200000  BitMask --> 000000000000001000000000000000000000
$aLogicalProcessors[22] = 0x00400000  BitMask --> 000000000000010000000000000000000000
$aLogicalProcessors[23] = 0x00800000  BitMask --> 000000000000100000000000000000000000
$aLogicalProcessors[24] = 0x01000000  BitMask --> 000000000001000000000000000000000000
$aLogicalProcessors[25] = 0x02000000  BitMask --> 000000000010000000000000000000000000
$aLogicalProcessors[26] = 0x04000000  BitMask --> 000000000100000000000000000000000000
$aLogicalProcessors[27] = 0x08000000  BitMask --> 000000001000000000000000000000000000
$aLogicalProcessors[28] = 0x10000000  BitMask --> 000000010000000000000000000000000000
$aLogicalProcessors[29] = 0x20000000  BitMask --> 000000100000000000000000000000000000
$aLogicalProcessors[30] = 0x40000000  BitMask --> 000001000000000000000000000000000000
$aLogicalProcessors[31] = 0x80000000  BitMask --> 000010000000000000000000000000000000
$aLogicalProcessors[32] = 0x00000000  BitMask --> 000000000000000000000000000000000000
$aLogicalProcessors[33] = 0x00000000  BitMask --> 000000000000000000000000000000000000
$aLogicalProcessors[34] = 0x00000000  BitMask --> 000000000000000000000000000000000000
$aLogicalProcessors[35] = 0x00000000  BitMask --> 000000000000000000000000000000000000

- Default AffinityMask
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0xFFFFFFFF    Process affinity mask        BitMask --> 000011111111111111111111111111111111
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 24        $aLogicalProcessors[24] --> 0x01000000

- New AffinityMask ($iMask = 0x00000001)
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0x00000001    Process affinity mask        BitMask --> 000000000000000000000000000000000001
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 0        $aLogicalProcessors[0] --> 0x00000001

- New AffinityMask ($iMask = 0x00000002)
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0x00000002    Process affinity mask        BitMask --> 000000000000000000000000000000000010
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 1        $aLogicalProcessors[1] --> 0x00000002

- New AffinityMask ($iMask = 0x00000008)
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0x00000008    Process affinity mask        BitMask --> 000000000000000000000000000000001000
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 3        $aLogicalProcessors[3] --> 0x00000008

- New AffinityMask ($iMask = 0x00000030)
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0x00000030    Process affinity mask        BitMask --> 000000000000000000000000000000110000
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 4        $aLogicalProcessors[4] --> 0x00000010

- New AffinityMask ($iMask = 0x00000090)
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0x00000090    Process affinity mask        BitMask --> 000000000000000000000000000010010000
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 4        $aLogicalProcessors[4] --> 0x00000010

- New AffinityMask ($iMask = 0x00009800)
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0x00009800    Process affinity mask        BitMask --> 000000000000000000001001100000000000
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 11        $aLogicalProcessors[11] --> 0x00000800

- New AffinityMask ($iMask = 0x00001800)
> $aAffinityMask[0]    = True        True on success, otherwise False
> $aAffinityMask[1]    = 0x00001800    Process affinity mask        BitMask --> 000000000000000000000001100000000000
> $aAffinityMask[2]    = 0xFFFFFFFF    System affinity mask        BitMask --> 000011111111111111111111111111111111
+ Used ProcessorNumber = 11        $aLogicalProcessors[11] --> 0x00000800

! $iMask (-1) ist zu klein! (1 to 68719476735 for 36 Logical Processors)

+>07:08:39 AutoIt3.exe ended.rc:0
+>07:08:39 AutoIt3Wrapper Finished.
>Exit code: 0    Time: 2.084

Alles anzeigen

**Bitnugger**

Zitat von Ovik

Mir ist nun auch klar, warum die Prozessoren 32-35 nicht ansprechbar sind (Maske hat ja nur 32 Bits).

Hihi, fast richtig!

Schau mal hier...

Code

; Was in deiner Ausgabe angezeigt wird:
$aLogicalProcessors[35] = 0x00000000 BitMask --> 000000000000000000000000000000000000

; Die Stellen der BitMask sind so schwer zu zählen... deshalb machen wir es mal etwas übersichtlicher...
;                                                [ 32-35  ] [ 24-31  ] [ 16-23  ] [  8-15  ] [  0-7   ]
$aLogicalProcessors[35] = 0x00000000 BitMask -->      0000   00000000   00000000   00000000   00000000

; Wie du nun sehen kannst, sind es mehr als 32 Bit, die hier angezeigt werden:
;                                                [ 32-35  ] [ 24-31  ] [ 16-23  ] [  8-15  ] [  0-7   ]
$aLogicalProcessors[35] = 0x00000000 BitMask -->      1000   00000000   00000000   00000000   00000000
; Hier sollte bei dir aber eine 1 stehen..............^

; *************************************************************************************************************************************
; Die 1-Million-Dollar-Frage ist nun: Warum ist dies bei dir aber nicht der Fall?
; *************************************************************************************************************************************

; #####################################################################################################################################
; 1. Fehler)
; #####################################################################################################################################
$g_aLogicalProcessors[$i] = '0x' & Hex(Int(2^$i), 8) ; Hex(2^$i, 8) geht nicht, weil Hex(2^0) fälschlicherweise 0x3FF0000000000000 ist, und nicht 0x0000000000000001!
;  Hier darf nicht Hex(Int(2^$i), 8) stehen, weil wir ja mit mehr als 32 Bits hantieren müssen, uns aber mit Hex(expression, 8) aber auf 32 Bits beschränken.

; Richtig wäre also:
$g_aLogicalProcessors[$i] = '0x' & Hex(Int(2^$i), 16) ; Hex(2^$i, 16) geht nicht, weil Hex(2^0) fälschlicherweise 0x3FF0000000000000 ist, und nicht 0x0000000000000001!

; Korrigieren wir diesen Fehler, sollte die Ausgabe bei dir so aussehen:
$aLogicalProcessors[35] = 0x0000000080000000 BitMask --> 100000000000000000000000000000000000
; Doch auch jetzt hast du hier keine 1 stehen............^

; #####################################################################################################################################
; 2. Fehler) Das BitOR in der Funktion _Example und das BitAND in der Funktion _UsedLogicalProcessorsToBinaryString
; #####################################################################################################################################
; Das BitOR in der Funktion _Example:
If UBound($aLogicalProcessors) >= 32 Then _SetProcessAffinityMask(@AutoItPID, BitOR($aLogicalProcessors[11], $aLogicalProcessors[12], $aLogicalProcessors[31]))

; Das BitAND in der Funktion _UsedLogicalProcessorsToBinaryString:
$bAffinityMask &= BitAND($iUsedLogicalProcessors, 2^$i) ? '1' : '0'

; Erklärung... der für $aLogicalProcessors[35] gespeicherte Wert ist nach der ersten Korrektur: '0x' & Hex(2^35, 16) --> 0x0000000800000000 - entspricht Integer --> 34359738368.

; Wenn $i also 35 ist... und wir nun die entsprechenden Werte anstelle der Variablen einsetzen, sähe das so aus...
$bAffinityMask &= BitAND(34359738368, 2^35) ? '1' : '0' ; hier liefert BitAND aber den Wert 0 und das Ergebnis in der BitMask ist somit auch eine '0'
; DAS funktioniert so nicht... weil... wie in der AutoIt-Hilfe zu BitAND auch steht: >>>Bit operations are performed as 32-bit integers.<<<
; BitAND(34359738368, 34359738368)                             = 0
; BitAND(0x800000000, 0x800000000)                             = 0
; BitAND(0x0000000800000000, 0x0000000800000000)               = 0

; *************************************************************************************************************************************
; Wir haben ab $aLogicalProcessors[32] also einen Wert, der mehr als 32 Bits benötigt... derselbe Fehler tritt ergo auch bei BitOR auf!
; *************************************************************************************************************************************

; Und nu?
; Wir brauchen ein BitOR/BitAND, dass mit mehr als 32 Bit funktioniert... ist in Arbeit... aber heute nicht mehr!

; Vielleicht hat ja einer der User hier eine fertige Lösung parat? - oder ich bin mal wieder mächtig auf dem Holzweg. ;-)

Alles anzeigen

**Musashi**

Zitat von Bitnugger

; Und nun ?
; Wir brauchen ein BitOR/BitAND, dass mit mehr als 32 Bit funktioniert... ist in Arbeit...
; Vielleicht hat ja einer der User hier eine fertige Lösung parat ?

Andy wird, wie angekündigt, in Kürze seine gewohnt elegante Lösung präsentieren !

Vielleicht ist aber auch der folgende Link für Dich interessant :

https://www.autoitscript.com/forum/topic/131037-binary-udf/

Da der Originalposter Ward alle seine Dateien aus dem engl. Forum entfernt hat, wurde der (letzte?) Stand von argumentum am 12. Jan 2017 erneut gepostet : Binary UDF[2011.09.15].zip und die entpackten .au3-Dateien

Gruß Musashi

**Oscar**

Zitat von Bitnugger

Vielleicht hat ja einer der User hier eine fertige Lösung parat?

Ich habe eben mal eine Assembler-UDF erstellt: BitOperations64

**Bitnugger**

Musashi & Oscar - Vielen Dank!

Binary.au3 - habe ich ~~auf die Schnelle~~ ein wenig geändert, weil durch folgende Zeile (und die bleibt drin!) sonst Fehler ohne Ende angezeigt werden:

#AutoIt3Wrapper_AU3Check_Parameters=-q -d -w 1 -w 2 -w 3 -w- 4 -w 5 -w 6 -w- 7

BitOperations64.au3 - habe ich ein wenig geändert, weil bei _BitAND64, _BitOR64 und _BitXOR64 nur zwei Parameter akzeptiert wurden, nun dürfen es bis zu 255 sein.

Schöner wäre, wenn das auch mit X86-Mode geht...

Hier mal die bei mir benötigten Zeiten für die Scripts _ProcessSetAffinityMask2 (Binary.au3).au3 und _ProcessSetAffinityMask3 (BitOperations64.au3).au3:

Binary.au3 (Ward, max. 20 Params) : Benötigte Zeit: 00:00:01:133:1685

Binary.au3 (Ward, max. 255 Params) : Benötigte Zeit: 00:00:01:249:1656

BitOperations64.au3 (Oscar, max. 20 Params) : Benötigte Zeit: 00:00:01:080:7824

BitOperations64.au3 (Oscar, max. 255 Params) : Benötigte Zeit: 00:00:01:181:7813

Ich habe das einfach mal alles in ein Archiv reingelegt, damit Ovik sich eine Version aussuchen kann...

Code: _ProcessSetAffinityMask.zip

_ProcessSetAffinityMask2 (Binary.au3).au3           9.436 Bytes
_ProcessSetAffinityMask3 (BitOperations64.au3).au3  9.593 Bytes
Binary.au3                                         43.300 Bytes
Binary (Ward, max.  20 Params).au3                 27.559 Bytes
Binary (Ward, max. 255 Params).au3                 43.300 Bytes
BinaryExample.au3                                   5.753 Bytes
BinarySpeedTest.au3                                 2.162 Bytes
BitOperations64.au3                                25.299 Bytes
BitOperations64 (Oscar, max.  20 Params).au3        9.558 Bytes
BitOperations64 (Oscar, max. 255 Params).au3       25.299 Bytes
BitOperations64_example.au3                         2.812 Bytes

Alles anzeigen

Die Ausgabe sieht dann bei mir so aus:

Ovik

manoman! Also Ihr (insbesondere Bitnugger) seid echt grossartig. Vielen vielen Dank für die super Hilfe

Weil BitOperations64 nicht mit X86 geht (bzw. mein Script bei X64 nicht mehr richtig läuft), habe ich das AffinityMask-Setzen in eine externe exe ausgelagert, die ich getrost mit X64 Mode kompilieren kann.

Ich werde mir dann noch genauer das Binary-Beispiel ansehen und das dann wohl im nächsten Schritt in mein Script integrieren.

Nochmals vielen Dank und schöne Festtage an alle!

-ovik

**Bitnugger**

Post #29: Binary.au3 jetzt auch mit max. 255 Params! Alles noch mal überarbeitet und optimiert.

**Oscar**

Zitat von Bitnugger

Schöner wäre, wenn das auch mit X86-Mode geht..

Naja, es geht schon, nur musst Du AutoIt dann irgendwie beibringen mit 64-Bit-Zahlen umzugehen.

Lo- und Hi-DWORD wäre so eine Möglichkeit.

**Andy**

Zitat von Bitnugger

Schöner wäre, wenn das auch mit X86-Mode geht...

Kein Thema, wenn du sagst wie du die 64-Bit-UINTs als Parameter bereitstellen willst^^

Zitat von Oscar

Lo- und Hi-DWORD wäre so eine Möglichkeit.

Na klasse, aus 2x32 Bit die "virtuellen" 64Bit machen um diese per 32-Bitmodus per SIMD (128Bit) oder gar (64Bit) MMX abzuwickeln und dann zurückzutransferieren?!

Dann kann imho besser man gleich die Binary-UDF benutzen und mit "Hex"-Strings arbeiten....

Zitat von Ovik

Weil BitOperations64 nicht mit X86 geht (bzw. mein Script bei X64 nicht mehr richtig läuft), habe ich das AffinityMask-Setzen in eine externe exe ausgelagert, die ich getrost mit X64 Mode kompilieren kann.

Naja, dann müssen wir diesen Tod halt sterben und was für 32Bit schnitzen

LO- und HIGH-DWORD als jeweils einzelnen Parameter übergeben und das Ergebnis wieder als LO-und HIGH-DWORD zurückgeben sollte ja das Problem nicht sein...hab kaum Zeit, zwischen den Jahren sollte das hinhauen...

Dann gleich als 128-Bit-Version (SSE)