def set_process_affinity_mask(pid, value):
pHandle = _get_handle_for_pid(pid, False)
current = win32process.GetProcessAffinityMask(pHandle)[0]
try:
win32process.SetProcessAffinityMask(pHandle, value)
except win32process.error as e:
raise ValueError
return current
def set_affinity(self, value):
pHandle = self._get_handle_for_pid(0, False)
current = win32process.GetProcessAffinityMask(pHandle)[0]
try:
win32process.SetProcessAffinityMask(pHandle, current)
except win32process.error as e:
print("unable to set process affinity")
raise ValueError(e)
return current
def set_affinity(pid=0, mask=1):
try:
hProc = __open_process(pid, ro=False)
mask_old, mask_sys_old = win32process.GetProcessAffinityMask(
hProc)
res = win32process.SetProcessAffinityMask(hProc, mask)
win32api.CloseHandle(hProc)
if res:
raise OSError
except win32process.error as e:
raise ValueError, e
return mask_old
def generate_main(queue: mp.Queue, worker_id, start, step, n):
print("[Worker %d] Spawn" % (worker_id, ))
wp.SetProcessAffinityMask(-1, 1 << worker_id)
wp.SetPriorityClass(-1, 0x00000040 | 0x00100000)
for i_sample in range(start, n, step):
freq_low, freq_high = sorted(
np.random.uniform(band_freq_list[0], band_freq_list[-1], size=2))
rd_low, rd_high = sorted(np.random.uniform(0.3, 3.0, size=2))
disto_low, disto_high = sorted(np.random.uniform(0.0, 0.1, size=2))
energy_low, energy_high = sorted(np.random.uniform(0.025, 1.0, size=2))
magn_low, magn_high = sorted(np.random.uniform(0.025, 1.0, size=2))
snr_low, snr_high = np.exp(
sorted(np.random.uniform(np.log(8), np.log(1e16), size=2)))
'''
rd_low, rd_high = 3.0, 3.0
disto_low, disto_high = 0.0, 0.1
energy_low, energy_high = 1.0, 1.0
magn_low, magn_high = 1.0, 1.0
snr_low, snr_high = 8, 8
'''
use_shape_noise = (np.random.randint(0, 2) == 1)
n_extend_hop = np.random.randint(0, 32)
#print("S0")
osr = np.random.choice(gvm_osr_list)
f0_list, w = generate_sample_0(freq_low, freq_high, rd_low, rd_high,
disto_low, disto_high, energy_low,
energy_high, magn_low, magn_high,
snr_low, snr_high, use_shape_noise, osr,
n_hop_per_sample + n_extend_hop)
cut_begin = np.random.randint(0, n_extend_hop + 1)
f0_list = f0_list[cut_begin:cut_begin + n_hop_per_sample]
#print("S1")
feature_list = generate_sample_1(w)[cut_begin:cut_begin +
n_hop_per_sample]
queue.put((i_sample, f0_list, feature_list))
'''
pl.figure()
pl.imshow(feature_list[:, :, 1].T, interpolation='nearest', aspect='auto', origin='lower', cmap="plasma")
pl.plot((freqToBark(f0_list) - band_start) / (band_stop - band_start) * n_band)
pl.figure()
pl.imshow(feature_list[:, :, 2].T, interpolation='nearest', aspect='auto', origin='lower', cmap="plasma")
pl.plot((freqToBark(f0_list) - band_start) / (band_stop - band_start) * n_band)
pl.figure()
pl.imshow(feature_list[:, :, 3].T, interpolation='nearest', aspect='auto', origin='lower', cmap="plasma", vmin=band_freq_list[0] / sr, vmax=band_freq_list[-1] / sr)
pl.plot((freqToBark(f0_list) - band_start) / (band_stop - band_start) * n_band)
pl.show()
'''
queue.put(worker_id)
def run(func, keys, max_procs=None, affinity=None, proc_desc='', **kwargs):
"""
Provide interface for multiprocessing
Args:
func: callable functions
keys: keys in kwargs that want to use process
max_procs: max number of processes
affinity: CPU affinity
proc_desc: prefix for progressbar
**kwargs: kwargs for func
"""
logger = logs.get_logger(run, level=kwargs.get('log', 'info'))
if max_procs is None: max_procs = cpu_count()
kw_arr = saturate_kwargs(keys=keys, **kwargs)
if len(kw_arr) == 0: return
if isinstance(affinity, int):
try:
import win32process
import win32api
win32process.SetProcessAffinityMask(win32api.GetCurrentProcess(),
affinity)
except Exception as e:
logger.error(str(e))
task_queue = queue.Queue()
with tqdm(total=len(kw_arr), desc=proc_desc) as bar:
while len(kw_arr) > 0:
for _ in range(max_procs):
if len(kw_arr) == 0: break
kw = kw_arr.pop(0)
bar.update()
p = Process(target=func, kwargs=kw)
p.start()
sys.stdout.flush()
task_queue.put(p)
while not task_queue.empty():
p = task_queue.get()
p.join()
def setPriority(self, pid=None, priority=2):
""" Set The Priority of a Windows Process. Priority is a value between 0-5 where
2 is normal priority. Default sets the priority of the current
python process but can take any valid process ID. """
import win32api, win32process, win32con
priorityClasses = [
win32process.IDLE_PRIORITY_CLASS,
win32process.BELOW_NORMAL_PRIORITY_CLASS,
win32process.NORMAL_PRIORITY_CLASS,
win32process.ABOVE_NORMAL_PRIORITY_CLASS,
win32process.HIGH_PRIORITY_CLASS,
win32process.REALTIME_PRIORITY_CLASS
]
pid = win32api.GetCurrentProcessId()
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetPriorityClass(handle, priorityClasses[priority])
win32process.SetProcessAffinityMask(handle, 1)
def SetupProcessors(cluster):
if sys.platform != "win32":
return
handle = win32api.GetCurrentProcess()
processMask, systemMask = win32process.GetProcessAffinityMask(handle)
ht = False
if systemMask & 8:
#we're going to count this as a hyperthreaded system
#as we don't currently have any servers with > 2 physical cpu
ht = True
if cluster == 0:
mask = 3 if ht else 1
elif cluster == 1:
mask = 12 if ht else 2
else:
mask = 1
print "Setting Processor Affinity Mask to", mask
win32process.SetProcessAffinityMask(handle, mask)
def sched_setaffinity(pid, mask):
pid = pid or os.getpid()
handle = win32api.OpenProcess(win32con.PROCESS_SET_INFORMATION, False, pid)
win32process.SetProcessAffinityMask(handle, _cores_to_mask(mask))
def setaffinity():
pid = win32api.GetCurrentProcessId()
mask = 3 # core 7
handle = win32api.OpenProcess(win32con.PROCESS_ALL_ACCESS, True, pid)
win32process.SetProcessAffinityMask(handle, mask)
for h, t in hwnd_title.items():
if t is not "":
print(h, t)
if __name__ == '__main__':
all_memory_address = {"mutil": 0x0061BD9C, "signal": 0x0053B644}
game_window_text = "[#] 棆揹嘨 (C)2005-2006 MOSS LTD ALL RIGHTS RESERVED. [#]"
win32_raiden3 = Window(game_window_text)
win32_raiden3.get_all_hwnds_from_text()
process_id = win32process.GetWindowThreadProcessId(
win32_raiden3.hwnd_title[0])[1]
process_handle = win32api.OpenProcess(0x1F0FFF, False, process_id)
win32process.SetProcessAffinityMask(process_handle, 0x0001)
process_id = win32process.GetWindowThreadProcessId(
win32_raiden3.hwnd_title[1])[1]
process_handle = win32api.OpenProcess(0x1F0FFF, False, process_id)
win32process.SetProcessAffinityMask(process_handle, 0x0002)
proc1 = mp.Process(target=proces1, args=(win32_raiden3.hwnd_title[0], ))
proc2 = mp.Process(target=proces1, args=(win32_raiden3.hwnd_title[1], ))
proc1.start()
proc2.start()
process_handle1 = win32api.OpenProcess(0x1F0FFF, False, proc1.pid)
win32process.SetProcessAffinityMask(process_handle1, 0x0004)
process_handle2 = win32api.OpenProcess(0x1F0FFF, False, proc2.pid)
