def mat_vec(A: List[List[int]], x: List[int]) -> List[int]:
N = len(A)
y = [0] * N
f = partial(calc, A=A, x=x, y=y)
pool = ProcessPoolExecutor(max_workers=2)
pool.map(f, [i for i in range(N)])
pool.shutdown(wait=True)
return y
def test_search_by_process_pool():
search_paths = get_search_paths()
pool = ProcessPoolExecutor(max_workers=12)
start = time.time()
result = list(pool.map(count_right_by_path, search_paths))
end = time.time()
print(sum(result) / 100) # vgg16 准确率0.99
print('使用多进程--timestamp:{:.3f}'.format(end-start)) # vgg16 130.886
class SnakeGameExecutor(object):
def __init__(self, args):
self.hpv = args.host, args.port, args.venue
self.executor = ProcessPoolExecutor(max_workers=(os.cpu_count()))
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.executor.shutdown(wait=True)
return False
def run_batch(self, batch):
params = [(*self.hpv, snake) for snake in batch]
return self.executor.map(run_simulation, params)
"""
import time
from concurrent.futures.process import ProcessPoolExecutor
from concurrent.futures.thread import ThreadPoolExecutor
def gcd(pair):
"""
gcd
@param pair:
@return:
"""
a, b = pair
low = min(a, b)
for i in range(low, 0, -1):
if a % i == 0 and b % i == 0:
return i
if __name__ == '__main__':
numbers = [(1963309, 2265973), (2030677, 3814172), (1551645, 2229620),
(2039045, 2020802)]
start = time.time()
# results = list(map(gcd, numbers))
# pool = ThreadPoolExecutor(max_workers=4)
# results = list(pool.map(gcd, numbers))
pool = ProcessPoolExecutor(max_workers=4)
results = list(pool.map(gcd, numbers))
end = time.time()
print('Took %.3f seconds' % (end - start))
def do_test3(workers):
param = {"max_workers": workers}
loop = asyncio.new_event_loop()
lock = threading.Lock()
tresult = []
presult = []
cresult = []
pre_input1 = input_generator(workers, 0)
pre_input2 = input_generator(workers, max(pre_input1))
pre_input3 = input_generator(workers, max(pre_input2))
def result_checker(list, lock, fut):
with lock:
try:
list.append(fut.result())
except Exception as e:
list.append(e)
texec = ThreadPoolExecutor(**param)
pexec = ProcessPoolExecutor(**param)
cexec = CoroutinePoolExecutor(**param, loop=loop)
tstart = round(time.time() + 1)
input1 = [tstart + i for i in pre_input1]
input2 = [tstart + i for i in pre_input2]
input3 = [tstart + i for i in pre_input3]
for x in input1:
future = texec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, tresult, lock))
result_iter = texec.map(wake_at, input2)
for x in input3:
future = texec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, tresult, lock))
for x in result_iter:
with lock:
tresult.append(x)
texec.shutdown(True)
pstart = round(time.time() + _start_warm_up)
input1 = [pstart + i for i in pre_input1]
input2 = [pstart + i for i in pre_input2]
input3 = [pstart + i for i in pre_input3]
for x in input1:
future = pexec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, presult, lock))
result_iter = pexec.map(wake_at, input2)
for x in input3:
future = pexec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, presult, lock))
for x in result_iter:
with lock:
presult.append(x)
pexec.shutdown(True)
cstart = round(time.time() + _start_warm_up)
input1 = [cstart + i for i in pre_input1]
input2 = [cstart + i for i in pre_input2]
input3 = [cstart + i for i in pre_input3]
async def async_main():
for x in input1:
future = cexec.submit(async_wake_at, x)
future.add_done_callback(
functools.partial(result_checker, cresult, lock))
result_iter = cexec.map(async_wake_at, input2)
for x in input3:
future = cexec.submit(async_wake_at, x)
future.add_done_callback(
functools.partial(result_checker, cresult, lock))
async for x in result_iter:
with lock:
cresult.append(x)
await cexec.shutdown(False)
loop.run_until_complete(async_main())
try:
loop.run_until_complete(cexec.shutdown(True))
texec.shutdown(True)
pexec.shutdown(True)
finally:
loop.close()
tresult = [round((x - tstart) / _precision) for x in tresult]
presult = [round((x - pstart) / _precision) for x in presult]
cresult = [round((x - cstart) / _precision) for x in cresult]
result = True
for (t, p, c) in zip(tresult, presult, cresult):
result = result and (t == p)
if not result:
print(tresult)
print(presult)
print(cresult)
print(t, p, c)
assert False
result = result and (p == c)
if not result:
print(tresult)
print(presult)
print(cresult)
print(t, p, c)
assert False
result = result and (c == t)
if not result:
print(tresult)
print(presult)
print(cresult)
print(t, p, c)
assert False
return result
end = unit
while end <= total_no_of_results:
ranges.append([start, end])
start = end
end = end + unit
def genResults(the_range):
print(f"start:{the_range[0]} - end:{the_range[1]}")
rs_store = []
for i in range(the_range[0], the_range[1]):
rs_loto = Game649().playMaxGameUnits()
rs_store.append(rs_loto)
for rs in rs_store:
for r in rs.results:
wd = WinningsDetector(rc, r)
wd.getWinning()
if wd.match_count > 5:
print(wd.match_count)
if __name__ == "__main__":
start = tm.default_timer()
prl = ProcessPoolExecutor(4)
future_results = prl.map(genResults, ranges)
prl.shutdown()
rs_store = []
end = tm.default_timer() - start
print(end)
Decimal(8 * _n + 4) - Decimal(1) / Decimal(8 * _n + 5) -
Decimal(1) / Decimal(8 * _n + 6)) / Decimal(getPow(16, _n))
return result
if __name__ == '__main__':
n = input()
start = time.time()
params = list(tqdm([i for i in range(int(n))],
desc="Creating params list"))
# noinspection SpellCheckingInspection
getcontext().prec = int(n)
pool = ProcessPoolExecutor(max_workers=16)
print("start")
results = list(
tqdm(pool.map(getPi, params),
total=len(params),
desc='Calculating pi with bbp：'))
end = time.time()
print("use %fs" % (end - start))
pi = Decimal(0)
for r in results:
pi += r
# print(pi)
with open('pi.txt', 'w') as f:
f.write(str(pi))
print('saving to pi.txt({}B)'.format(os.stat('pi.txt').st_size))
com = input('Open file?([y]/n):')
if com == 'y' or com == '':
subprocess.Popen(
def do_test3(workers):
param = {"max_workers": workers}
loop = asyncio.new_event_loop()
lock = threading.Lock()
tresult = []
presult = []
cresult = []
pre_input1 = input_generator(workers, 0)
pre_input2 = input_generator(workers, max(pre_input1))
pre_input3 = input_generator(workers, max(pre_input2))
def result_checker(list, lock, fut):
with lock:
try:
list.append(fut.result())
except Exception as e:
list.append(e)
texec = ThreadPoolExecutor(**param)
pexec = ProcessPoolExecutor(**param)
cexec = CoroutinePoolExecutor(**param, loop=loop)
tstart = round(time.time()+1)
input1 = [tstart + i for i in pre_input1]
input2 = [tstart + i for i in pre_input2]
input3 = [tstart + i for i in pre_input3]
for x in input1:
future = texec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, tresult, lock))
result_iter = texec.map(wake_at, input2)
for x in input3:
future = texec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, tresult, lock))
for x in result_iter:
with lock:
tresult.append(x)
texec.shutdown(True)
pstart = round(time.time() + _start_warm_up)
input1 = [pstart + i for i in pre_input1]
input2 = [pstart + i for i in pre_input2]
input3 = [pstart + i for i in pre_input3]
for x in input1:
future = pexec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, presult, lock))
result_iter = pexec.map(wake_at, input2)
for x in input3:
future = pexec.submit(wake_at, x)
future.add_done_callback(
functools.partial(result_checker, presult, lock))
for x in result_iter:
with lock:
presult.append(x)
pexec.shutdown(True)
cstart = round(time.time() + _start_warm_up)
input1 = [cstart + i for i in pre_input1]
input2 = [cstart + i for i in pre_input2]
input3 = [cstart + i for i in pre_input3]
async def async_main():
for x in input1:
future = cexec.submit(async_wake_at, x)
future.add_done_callback(
functools.partial(result_checker, cresult, lock))
result_iter = cexec.map(async_wake_at, input2)
for x in input3:
future = cexec.submit(async_wake_at, x)
future.add_done_callback(
functools.partial(result_checker, cresult, lock))
async for x in result_iter:
with lock:
cresult.append(x)
await cexec.shutdown(False)
loop.run_until_complete(async_main())
try:
loop.run_until_complete(cexec.shutdown(True))
texec.shutdown(True)
pexec.shutdown(True)
finally:
loop.close()
tresult = [round((x - tstart) / _precision) for x in tresult]
presult = [round((x - pstart) / _precision) for x in presult]
cresult = [round((x - cstart) / _precision) for x in cresult]
result = True
for (t, p, c) in zip(tresult, presult, cresult):
result = result and (t == p)
if not result:
print(tresult)
print(presult)
print(cresult)
print(t,p,c)
assert False
result = result and (p == c)
if not result:
print(tresult)
print(presult)
print(cresult)
print(t, p, c)
assert False
result = result and (c == t)
if not result:
print(tresult)
print(presult)
print(cresult)
print(t, p, c)
assert False
return result
