def test_get_context_using_python3_posix():
""" get_context() respects configuration.
If default context is changed this test will need to change too.
"""
assert get_context() is multiprocessing.get_context(None)
with dask.config.set({"multiprocessing.context": "forkserver"}):
assert get_context() is multiprocessing.get_context("forkserver")
with dask.config.set({"multiprocessing.context": "spawn"}):
assert get_context() is multiprocessing.get_context("spawn")
def get_multiproc_context(capabilities):
best_concurrency = capabilities.get('Process Startup Method', 'fork')
if hasattr(multiprocessing, 'get_context'):
for each in (best_concurrency, 'fork', 'spawn'):
if hasattr(multiprocessing, 'get_all_start_methods'):
if each in multiprocessing.get_all_start_methods():
return multiprocessing.get_context(each)
else:
try:
return multiprocessing.get_context(each)
except ValueError:
pass # invalid concurrency for this system
return None
def testfs(tmpdir):
# We can't use forkserver or spawn because of
# https://github.com/pytest-dev/pytest/issues/958.
if hasattr(multiprocessing, 'get_context'):
mp = multiprocessing.get_context('fork')
else:
# Older versions only support *fork* anyway
mp = multiprocessing
if threading.active_count() != 1:
raise RuntimeError("Multi-threaded test running is not supported")
mnt_dir = str(tmpdir)
with mp.Manager() as mgr:
cross_process = mgr.Namespace()
mount_process = mp.Process(target=run_fs,
args=(mnt_dir, cross_process))
mount_process.start()
try:
wait_for_mount(mount_process, mnt_dir)
yield (mnt_dir, cross_process)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def test_read_text(hdfs):
db = pytest.importorskip('dask.bag')
import multiprocessing as mp
pool = mp.get_context('spawn').Pool(2)
with hdfs.open('%s/text.1.txt' % basedir, 'wb') as f:
f.write('Alice 100\nBob 200\nCharlie 300'.encode())
with hdfs.open('%s/text.2.txt' % basedir, 'wb') as f:
f.write('Dan 400\nEdith 500\nFrank 600'.encode())
with hdfs.open('%s/other.txt' % basedir, 'wb') as f:
f.write('a b\nc d'.encode())
b = db.read_text('hdfs://%s/text.*.txt' % basedir)
with dask.config.set(pool=pool):
result = b.str.strip().str.split().map(len).compute()
assert result == [2, 2, 2, 2, 2, 2]
b = db.read_text('hdfs://%s/other.txt' % basedir)
with dask.config.set(pool=pool):
result = b.str.split().flatten().compute()
assert result == ['a', 'b', 'c', 'd']
def _exec_task_process(self, ctxt, task_id, task_type, origin, destination,
instance, task_info):
mp_ctx = multiprocessing.get_context('spawn')
mp_q = mp_ctx.Queue()
mp_log_q = mp_ctx.Queue()
p = mp_ctx.Process(
target=_task_process,
args=(ctxt, task_id, task_type, origin, destination, instance,
task_info, mp_q, mp_log_q))
p.start()
LOG.info("Task process started: %s", task_id)
self._rpc_conductor_client.set_task_host(
ctxt, task_id, self._server, p.pid)
self._handle_mp_log_events(p, mp_log_q)
p.join()
if mp_q.empty():
raise exception.CoriolisException("Task canceled")
result = mp_q.get(False)
if isinstance(result, str):
raise exception.TaskProcessException(result)
return result
def __init__(self, host='127.0.0.1', http_port=9786, tcp_port=8786,
bokeh_port=8787, bokeh_whitelist=[], log_level='info',
show=False, prefix=None, use_xheaders=False):
self.port = bokeh_port
ip = socket.gethostbyname(host)
hosts = ['localhost',
'127.0.0.1',
ip,
host]
with ignoring(Exception):
hosts.append(socket.gethostbyname(ip))
with ignoring(Exception):
hosts.append(socket.gethostbyname(socket.gethostname()))
hosts = ['%s:%d' % (h, bokeh_port) for h in hosts]
hosts.append("*")
hosts.extend(map(str, bokeh_whitelist))
args = ([binname, 'serve'] + paths +
['--log-level', 'warning',
'--check-unused-sessions=50',
'--unused-session-lifetime=1',
'--port', str(bokeh_port)] +
sum([['--host', h] for h in hosts], []))
if prefix:
args.extend(['--prefix', prefix])
if show:
args.append('--show')
if use_xheaders:
args.append('--use-xheaders')
if log_level in ('debug', 'info', 'warning', 'error', 'critical'):
args.extend(['--log-level', log_level])
bokeh_options = {'host': host,
'http-port': http_port,
'tcp-port': tcp_port,
'bokeh-port': bokeh_port}
with open('.dask-web-ui.json', 'w') as f:
json.dump(bokeh_options, f, indent=2)
if sys.version_info[0] >= 3:
from bokeh.command.bootstrap import main
ctx = multiprocessing.get_context('spawn')
self.process = ctx.Process(target=main, args=(args,))
self.process.daemon = True
self.process.start()
else:
import subprocess
self.process = subprocess.Popen(args)
logger.info(" Bokeh UI at: http://%s:%d/status/"
% (ip, bokeh_port))
def test_ipc_handle_serialization(self):
# prepare data for IPC
arr = np.arange(10, dtype=np.intp)
devarr = cuda.to_device(arr)
# create IPC handle
ctx = cuda.current_context()
ipch = ctx.get_ipc_handle(devarr.gpu_data)
# pickle
buf = pickle.dumps(ipch)
ipch_recon = pickle.loads(buf)
self.assertIs(ipch_recon.base, None)
self.assertEqual(tuple(ipch_recon.handle), tuple(ipch.handle))
self.assertEqual(ipch_recon.size, ipch.size)
# spawn new process for testing
ctx = mp.get_context('spawn')
result_queue = ctx.Queue()
args = (ipch, result_queue)
proc = ctx.Process(target=serialize_ipc_handle_test, args=args)
proc.start()
succ, out = result_queue.get()
if not succ:
self.fail(out)
else:
np.testing.assert_equal(arr, out)
proc.join(3)
def test_ipc_handle(self):
# prepare data for IPC
arr = np.arange(10, dtype=np.intp)
devarr = cuda.to_device(arr)
# create IPC handle
ctx = cuda.current_context()
ipch = ctx.get_ipc_handle(devarr.gpu_data)
# manually prepare for serialization as bytes
handle_bytes = bytes(ipch.handle)
size = ipch.size
# spawn new process for testing
ctx = mp.get_context('spawn')
result_queue = ctx.Queue()
args = (handle_bytes, size, result_queue)
proc = ctx.Process(target=base_ipc_handle_test, args=args)
proc.start()
succ, out = result_queue.get()
if not succ:
self.fail(out)
else:
np.testing.assert_equal(arr, out)
proc.join(3)
def start_child(self):
ctx = mp.get_context(self.SPAWN_METHOD)
state = ctx.Value(_State, False, False, False)
process = ctx.Process(target=_worker,
args=(state, self.loader))
process.start()
asyncio.async(self.connect(process, state))
def __init__(self, initialValue = None):
ctx = multiprocessing.get_context()
self.mgr = multiprocessing.Manager()
self.data = self.mgr.dict()
self.data["value"] = initialValue
self.condition = ctx.Condition()
def main():
ctx = mp.get_context('spawn')
q = ctx.Queue()
p = ctx.Process(target=foo, args=(q,))
p.start()
print(q.get())
p.join()
def __init__(self):
self.ctx = multiprocessing.get_context()
self.consumers = {}
self.queue = self.ctx.Queue()
self.broadcast = BroadcastValue()
self.threads = []
self.object = None
def main(center, host, port, http_port, bokeh_port, show, _bokeh, bokeh_whitelist):
given_host = host
host = host or get_ip()
ip = socket.gethostbyname(host)
loop = IOLoop.current()
scheduler = Scheduler(center, ip=ip,
services={('http', http_port): HTTPScheduler})
if center:
loop.run_sync(scheduler.sync_center)
scheduler.start(port)
if _bokeh:
try:
import bokeh
import distributed.bokeh
hosts = ['%s:%d' % (h, bokeh_port) for h in
['localhost', '127.0.0.1', ip, socket.gethostname(),
host] + list(bokeh_whitelist)]
dirname = os.path.dirname(distributed.__file__)
paths = [os.path.join(dirname, 'bokeh', name)
for name in ['status', 'tasks']]
binname = sys.argv[0][:-len('dscheduler')] + 'bokeh'
args = ([binname, 'serve'] + paths +
['--log-level', 'warning',
'--check-unused-sessions=50',
'--unused-session-lifetime=1',
'--port', str(bokeh_port)] +
sum([['--host', host] for host in hosts], []))
if show:
args.append('--show')
bokeh_options = {'host': host if given_host else '127.0.0.1',
'http-port': http_port,
'tcp-port': port,
'bokeh-port': bokeh_port}
with open('.dask-web-ui.json', 'w') as f:
json.dump(bokeh_options, f, indent=2)
if sys.version_info[0] >= 3:
from bokeh.command.bootstrap import main
ctx = multiprocessing.get_context('spawn')
bokeh_proc = ctx.Process(target=main, args=(args,))
bokeh_proc.daemon = True
bokeh_proc.start()
else:
bokeh_proc = subprocess.Popen(args)
logger.info(" Bokeh UI at: http://%s:%d/status/"
% (ip, bokeh_port))
except ImportError:
logger.info("Please install Bokeh to get Web UI")
except Exception as e:
logger.warn("Could not start Bokeh web UI", exc_info=True)
loop.start()
loop.close()
scheduler.stop()
bokeh_proc.terminate()
logger.info("End scheduler at %s:%d", ip, port)
def loadAttributes( self, numberOfThreads = 7 ):
# Put the driver directories in a queue
ctx = multiprocessing.get_context('fork')
driversInQueue = ctx.Queue()
driverFiles = os.listdir( self.__dir )
numberOfDriversToProcess = 0
for driverFile in driverFiles:
driverId = int(int(driverFile.split('.')[0]))
driver = Driver( driverId )
driversInQueue.put( driver )
numberOfDriversToProcess += 1
# The thread reading function
def readDataFunction( inputQueue, outputQueue, driverTopDir ):
while True:
driver = inputQueue.get()
driver.readTripsFromDirectory( self.__dir )
numberOfTrips = driver.numberOfTrips()
tripData = []
for i in range(numberOfTrips):
trip = driver.getTrip( i + 1 )
values, labels = trip.attributes()
tripData.append( ( trip.id(), values, labels ) )
outputQueue.put( (driver.id(), tripData ) )
return
# Start the reading threads
threads = []
driversOutQueue = ctx.Queue()
for i in range( numberOfThreads):
thread = ctx.Process( target = readDataFunction, args = (driversInQueue, driversOutQueue, self.__dir ) )
thread.start()
threads.append( thread )
# Set up the logger
log = ProcessLogger( numberOfDriversToProcess, "Drivers processed : " )
outputData = []
labels = []
for i in range( numberOfDriversToProcess ):
driverId, tripData = driversOutQueue.get()
# Loop over the trips for this driver
for trip in tripData:
if len(labels) == 0: # This is the first entry. Retrieve the header.
labels.append( 'driverId' )
labels.append( 'tripId' )
for label in trip[2]:
labels.append(label)
outputData = numpy.array([]).reshape(0,len(labels))
tripId = trip[0]
attributes = trip[1]
tripRow = numpy.hstack( (driverId, tripId, attributes) )
outputData = numpy.vstack( (outputData, tripRow) )
log.taskEnded()
for t in threads:
t.terminate()
return pandas.DataFrame(outputData, columns=labels)
def __init__(self, env_fns, spaces=None, context='spawn'):
"""
If you don't specify observation_space, we'll have to create a dummy
environment to get it.
"""
ctx = mp.get_context(context)
if spaces:
observation_space, action_space = spaces
else:
logger.log('Creating dummy env object to get spaces')
with logger.scoped_configure(format_strs=[]):
dummy = env_fns[0]()
observation_space, action_space = dummy.observation_space, dummy.action_space
dummy.close()
del dummy
VecEnv.__init__(self, len(env_fns), observation_space, action_space)
self.obs_keys, self.obs_shapes, self.obs_dtypes = obs_space_info(observation_space)
self.obs_bufs = [
{k: ctx.Array(_NP_TO_CT[self.obs_dtypes[k].type], int(np.prod(self.obs_shapes[k]))) for k in self.obs_keys}
for _ in env_fns]
self.parent_pipes = []
self.procs = []
with clear_mpi_env_vars():
for env_fn, obs_buf in zip(env_fns, self.obs_bufs):
wrapped_fn = CloudpickleWrapper(env_fn)
parent_pipe, child_pipe = ctx.Pipe()
proc = ctx.Process(target=_subproc_worker,
args=(child_pipe, parent_pipe, wrapped_fn, obs_buf, self.obs_shapes, self.obs_dtypes, self.obs_keys))
proc.daemon = True
self.procs.append(proc)
self.parent_pipes.append(parent_pipe)
proc.start()
child_pipe.close()
self.waiting_step = False
self.viewer = None
def _do():
mp_ctx = multiprocessing.get_context('spawn')
cpu_count = multiprocessing.cpu_count()
with ThreadPoolExecutor(max_workers=cpu_count) as executor:
yield from yield_pkgs(
executor, submit_pkgs(executor, [Package.root_package()], mp_ctx),
mp_ctx)
def pool(self):
return Pool(
processes=self.processes,
initializer=initializer,
initargs=self.initargs,
context=get_context('forkserver'),
)
def __init__(self, testcase_suite, manager):
self.keep_alive_parent_end, self.keep_alive_child_end = Pipe(
duplex=False)
self.finished_parent_end, self.finished_child_end = Pipe(duplex=False)
self.result_parent_end, self.result_child_end = Pipe(duplex=False)
self.testcase_suite = testcase_suite
if sys.version[0] == '2':
self.stdouterr_queue = manager.StreamQueue()
else:
from multiprocessing import get_context
self.stdouterr_queue = manager.StreamQueue(ctx=get_context())
self.logger = get_parallel_logger(self.stdouterr_queue)
self.child = Process(target=test_runner_wrapper,
args=(testcase_suite,
self.keep_alive_child_end,
self.stdouterr_queue,
self.finished_child_end,
self.result_child_end,
self.logger)
)
self.child.start()
self.last_test_temp_dir = None
self.last_test_vpp_binary = None
self._last_test = None
self.last_test_id = None
self.vpp_pid = None
self.last_heard = time.time()
self.core_detected_at = None
self.testcases_by_id = {}
self.testclasess_with_core = {}
for testcase in self.testcase_suite:
self.testcases_by_id[testcase.id()] = testcase
self.result = TestResult(testcase_suite, self.testcases_by_id)
def testfs(tmpdir):
# We can't use forkserver because we have to make sure
# that the server inherits the per-test stdout/stderr file
# descriptors.
if hasattr(multiprocessing, 'get_context'):
mp = multiprocessing.get_context('fork')
else:
# Older versions only support *fork* anyway
mp = multiprocessing
if threading.active_count() != 1:
raise RuntimeError("Multi-threaded test running is not supported")
mnt_dir = str(tmpdir)
with mp.Manager() as mgr:
cross_process = mgr.Namespace()
mount_process = mp.Process(target=run_fs,
args=(mnt_dir, cross_process))
mount_process.start()
try:
wait_for_mount(mount_process, mnt_dir)
yield (mnt_dir, cross_process)
except:
cleanup(mnt_dir)
raise
else:
umount(mount_process, mnt_dir)
def _launch(self):
context = multiprocessing.get_context('fork')
client_ch, server_ch = context.Pipe()
self.process = context.Process(
target=self.run_server, args=(server_ch, ), daemon=True)
self.process.start()
server_ch.close()
self.client_ch = Connection.from_Connection(client_ch)
def pool(self):
return Pool(
processes=self.queue_worker.processes,
initializer=initializer,
initargs=self.initargs,
maxtasksperchild=self.maxtasks,
context=get_context('forkserver'),
)
def init_pool(self):
return Pool(
processes=self.processes,
initializer=initializer,
initargs=self.initargs,
maxtasksperchild=self.maxtasks,
context=get_context('spawn'),
)
def test_no_collision(self):
bar1 = self.import_bar1()
bar2 = self.import_bar2()
with capture_cache_log() as buf:
res1 = bar1()
cachelog = buf.getvalue()
# bar1 should save new index and data
self.assertEqual(cachelog.count('index saved'), 1)
self.assertEqual(cachelog.count('data saved'), 1)
self.assertEqual(cachelog.count('index loaded'), 0)
self.assertEqual(cachelog.count('data loaded'), 0)
with capture_cache_log() as buf:
res2 = bar2()
cachelog = buf.getvalue()
# bar2 should save new index and data
self.assertEqual(cachelog.count('index saved'), 1)
self.assertEqual(cachelog.count('data saved'), 1)
self.assertEqual(cachelog.count('index loaded'), 0)
self.assertEqual(cachelog.count('data loaded'), 0)
self.assertNotEqual(res1, res2)
try:
# Make sure we can spawn new process without inheriting
# the parent context.
mp = multiprocessing.get_context('spawn')
except ValueError:
print("missing spawn context")
q = mp.Queue()
# Start new process that calls `cache_file_collision_tester`
proc = mp.Process(target=cache_file_collision_tester,
args=(q, self.tempdir,
self.modname_bar1,
self.modname_bar2))
proc.start()
# Get results from the process
log1 = q.get()
got1 = q.get()
log2 = q.get()
got2 = q.get()
proc.join()
# The remote execution result of bar1() and bar2() should match
# the one executed locally.
self.assertEqual(got1, res1)
self.assertEqual(got2, res2)
# The remote should have loaded bar1 from cache
self.assertEqual(log1.count('index saved'), 0)
self.assertEqual(log1.count('data saved'), 0)
self.assertEqual(log1.count('index loaded'), 1)
self.assertEqual(log1.count('data loaded'), 1)
# The remote should have loaded bar2 from cache
self.assertEqual(log2.count('index saved'), 0)
self.assertEqual(log2.count('data saved'), 0)
self.assertEqual(log2.count('index loaded'), 1)
self.assertEqual(log2.count('data loaded'), 1)
def get_context():
""" Return the current multiprocessing context."""
if sys.platform == "win32" or sys.version_info.major == 2:
# Just do the default, since we can't change it:
if config.get("multiprocessing.context", None) is not None:
warn(_CONTEXT_UNSUPPORTED, UserWarning)
return multiprocessing
context_name = config.get("multiprocessing.context", None)
return multiprocessing.get_context(context_name)
def main():
files = os.listdir(XML_FILES)
ctx = mp.get_context('fork')
q = ctx.Queue()
for host in files:
p = ctx.Process(target=worker, args=(host,q))
p.start()
p.join()
def test(self):
mp_ctx = multiprocessing.get_context('spawn')
with ThreadPoolExecutor(max_workers=2) as executor:
futs = [
executor.submit(util.isolated(task, i, mp_ctx)) for i in range(10)
]
time.sleep(2)
self.assertTrue(all(f.done() for f in futs))
self.assertTrue(all(f.result() % 2 == 0 for f in futs))
def __init__(self, *args, **kwargs):
if sys.version_info[0] <= 2:
super(Queue, self).__init__(*args, **kwargs)
else:
super(Queue, self).__init__(*args, ctx=multiprocessing.get_context(),
**kwargs)
self._reader = ConnectionWrapper(self._reader)
self._writer = ConnectionWrapper(self._writer)
self._send = self._writer.send
self._recv = self._reader.recv
def __init__(self, cards):
super(CardProgressQueue, self).__init__(
len(cards), ctx=multiprocessing.get_context())
self._cw = CardWidget()
widgets = [self._cw, ' ', progressbar.widgets.Bar(left='[', right=']'), ' ',
progressbar.widgets.SimpleProgress(), ' ', progressbar.widgets.ETA()]
self._pbar = progressbar.bar.ProgressBar(widgets=widgets, max_value=len(cards))
self._pbar.start()
for c in cards:
self.put(c)
def __init__(self, processes=None, initializer=None, initargs=(),
maxtasksperchild=None, context=None):
if context is None:
context = mp.get_context()
context = _nondaemon_context_mapper[context._name]
super(NonDaemonPool, self).__init__(processes=processes,
initializer=initializer,
initargs=initargs,
maxtasksperchild=maxtasksperchild,
context=context)
def __init__(self,
n_channels=2,
sample_rate=44100,
sample_width=2,
output_device_id=0,
input_device_id=0,
master_volume=1.0):
self.n_channels = n_channels
self.sample_rate = sample_rate
self.sample_width = sample_width
self.source_bank = SourceBank()
self.chunks_queue_size = 100
ctx = multiprocessing.get_context('spawn')
self.playback_queue = ctx.Queue(self.chunks_queue_size)
self.recording_queue = ctx.Queue(self.chunks_queue_size)
self.n_frames_per_chunk = 1024
self.playback_producer = PlaybackQueueProducer(
self.source_bank,
self.playback_queue,
self.n_channels,
self.sample_rate,
self.n_frames_per_chunk,
master_volume=master_volume)
self.audio_interface_process = ctx.Process(
target=playback_consumer,
args=(
self.playback_queue,
None, #self.recording_queue,
self.n_channels,
self.sample_rate,
self.sample_width,
self.n_frames_per_chunk,
output_device_id,
input_device_id))
self.recording_process = ctx.Process(
target=recording_consumer,
args=(
self.recording_queue,
self.sample_rate))
print("Launching processes")
self.audio_interface_process.daemmon = True
self.audio_interface_process.start()
self.recording_process.daemmon = True
self.recording_process.start()
class NoDaemonContext(type(multiprocessing.get_context())):
Process = NoDaemonProcess
def main():
graph, sess = load_graph(FLAGS.pre_trained_model_path)
cap = cv2.VideoCapture(0)
cap.set(cv2.CAP_PROP_FRAME_WIDTH, FLAGS.width)
cap.set(cv2.CAP_PROP_FRAME_HEIGHT, FLAGS.height)
mp = _mp.get_context("spawn")
v = mp.Value('i', 0)
lock = mp.Lock()
process = mp.Process(target=mario, args=(v, lock))
process.start()
line.sendtext('Start Game')
while True:
key = cv2.waitKey(1)
if key == ord("q"):
line.sendtext('End Game')
break
_, frame = cap.read()
frame = cv2.flip(frame, 1)
frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
boxes, scores, classes = detect_hands(frame, graph, sess)
frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
results = predict(boxes, scores, classes, FLAGS.threshold, FLAGS.width,
FLAGS.height)
if len(results) == 1:
x_min, x_max, y_min, y_max, category = results[0]
x = int((x_min + x_max) / 2)
y = int((y_min + y_max) / 2)
cv2.circle(frame, (x, y), 5, RED, -1)
if category == "Open" and x <= FLAGS.width / 3:
action = 7 # Left jump
text = "Jump Backward"
line.sendtext('Jump Backward')
elif category == "Closed" and x <= FLAGS.width / 3:
action = 6 # Left
text = "Run Backward"
line.sendtext('Run Backward')
elif category == "Open" and FLAGS.width / 3 < x <= 2 * FLAGS.width / 3:
action = 5 # Jump
text = "Jump"
line.sendtext('Jump')
elif category == "Closed" and FLAGS.width / 3 < x <= 2 * FLAGS.width / 3:
action = 0 # Do nothing
text = "Stop"
line.sendtext('Stop')
elif category == "Open" and x > 2 * FLAGS.width / 3:
action = 2 # Right jump
text = "Jump Forward"
line.sendtext('Jump Forward')
elif category == "Closed" and x > 2 * FLAGS.width / 3:
action = 1 # Right
text = "Run Forward"
line.sendtext('Run Forward')
else:
action = 0
text = "Stop"
line.sendtext('Stop')
with lock:
v.value = action
cv2.putText(frame, "{}".format(text), (x_min, y_min - 5),
cv2.FONT_HERSHEY_SIMPLEX, 0.5, GREEN, 2)
overlay = frame.copy()
cv2.rectangle(overlay, (0, 0), (int(FLAGS.width / 3), FLAGS.height),
BLUE, -1)
cv2.rectangle(overlay, (int(2 * FLAGS.width / 3), 0),
(FLAGS.width, FLAGS.height), BLUE, -1)
cv2.addWeighted(overlay, FLAGS.alpha, frame, 1 - FLAGS.alpha, 0, frame)
cv2.imshow('Detection', frame)
cap.release()
cv2.destroyAllWindows()
def get_context(self):
return get_context(self.ctx)
def run(config_cls=ConfigBuilder,
route_builder=None,
mp_context=None,
log_handlers=None,
**kwargs):
logger = get_logger("INFO", log_handlers)
if mp_context is None:
if hasattr(multiprocessing, "get_context"):
mp_context = multiprocessing.get_context()
else:
mp_context = MpContext()
with build_config(logger,
os.path.join(repo_root, "config.json"),
config_cls=config_cls,
**kwargs) as config:
# This sets the right log level
logger = get_logger(config.log_level, log_handlers)
bind_address = config["bind_address"]
if kwargs.get("alias_file"):
with open(kwargs["alias_file"], 'r') as alias_file:
for line in alias_file:
alias, doc_root = [x.strip() for x in line.split(',')]
config["aliases"].append({
'url-path': alias,
'local-dir': doc_root,
})
if route_builder is None:
route_builder = get_route_builder
routes = route_builder(logger, config.aliases, config).get_routes()
if config["check_subdomains"]:
check_subdomains(logger, config, routes, mp_context, log_handlers)
stash_address = None
if bind_address:
stash_address = (config.server_host, get_port(""))
logger.debug("Going to use port %d for stash" % stash_address[1])
with stash.StashServer(stash_address, authkey=str(uuid.uuid4())):
servers = start(logger, config, routes, mp_context, log_handlers,
**kwargs)
if not kwargs["exit_after_start"]:
try:
# Periodically check if all the servers are alive
server_process_exited = False
while not server_process_exited:
for server in iter_servers(servers):
server.proc.join(1)
if not server.proc.is_alive():
server_process_exited = True
break
except KeyboardInterrupt:
pass
failed_subproc = 0
for server in iter_servers(servers):
subproc = server.proc
if subproc.is_alive():
logger.info('Status of subprocess "%s": running',
subproc.name)
server.stop(timeout=1)
if server.proc.exitcode == 0:
logger.info('Status of subprocess "%s": exited correctly',
subproc.name)
else:
logger.warning(
'Status of subprocess "%s": failed. Exit with non-zero status: %d',
subproc.name, subproc.exitcode)
failed_subproc += 1
return failed_subproc
def map_unordered(cls,
function,
items,
multiprocess=False,
file=None,
step=100,
ipython_widget=False,
multiprocessing_start_method=None):
"""Map function over items, reporting the progress.
Does a `map` operation while displaying a progress bar with
percentage complete. The map operation may run on arbitrary order
on the items, and the results may be returned in arbitrary order.
::
def work(i):
print(i)
ProgressBar.map(work, range(50))
Parameters
----------
function : function
Function to call for each step
items : sequence
Sequence where each element is a tuple of arguments to pass to
*function*.
multiprocess : bool, int, optional
If `True`, use the `multiprocessing` module to distribute each task
to a different processor core. If a number greater than 1, then use
that number of cores.
ipython_widget : bool, optional
If `True`, the progress bar will display as an IPython
notebook widget.
file : writable file-like, optional
The file to write the progress bar to. Defaults to
`sys.stdout`. If ``file`` is not a tty (as determined by
calling its `isatty` member, if any), the scrollbar will
be completely silent.
step : int, optional
Update the progress bar at least every *step* steps (default: 100).
If ``multiprocess`` is `True`, this will affect the size
of the chunks of ``items`` that are submitted as separate tasks
to the process pool. A large step size may make the job
complete faster if ``items`` is very long.
multiprocessing_start_method : str, optional
Useful primarily for testing; if in doubt leave it as the default.
When using multiprocessing, certain anomalies occur when starting
processes with the "spawn" method (the only option on Windows);
other anomalies occur with the "fork" method (the default on
Linux).
"""
# concurrent.futures import here to avoid import failure when running
# in pyodide/Emscripten
from concurrent.futures import ProcessPoolExecutor, as_completed
results = []
if file is None:
file = _get_stdout()
with cls(len(items), ipython_widget=ipython_widget, file=file) as bar:
if bar._ipython_widget:
chunksize = step
else:
default_step = max(int(float(len(items)) / bar._bar_length), 1)
chunksize = min(default_step, step)
if not multiprocess or multiprocess < 1:
for i, item in enumerate(items):
results.append(function(item))
if (i % chunksize) == 0:
bar.update(i)
else:
ctx = multiprocessing.get_context(multiprocessing_start_method)
kwargs = dict(mp_context=ctx)
with ProcessPoolExecutor(
max_workers=(int(multiprocess)
if multiprocess is not True else None),
**kwargs) as p:
for i, f in enumerate(
as_completed(
p.submit(function, item) for item in items)):
bar.update(i)
results.append(f.result())
return results
async def __anit__(self, core):
await s_base.Base.__anit__(self)
self.core = core
self.iden = s_common.guid()
self.proc = None
self.ready = asyncio.Event()
self.mpctx = multiprocessing.get_context('spawn')
name = f'SpawnProc#{self.iden[:8]}'
self.threadpool = concurrent.futures.ThreadPoolExecutor(
max_workers=2, thread_name_prefix=name)
self.todo = self.mpctx.Queue()
self.done = self.mpctx.Queue()
self.proc = None # type: multiprocessing.Process
self.procstat = None
self.obsolete = False
spawninfo = await core.getSpawnInfo()
self.finievent = threading.Event()
@s_common.firethread
def procwaiter():
'''
Wait for child process to exit
'''
self.procstat = self.proc.join()
self.proc.close()
if not self.isfini:
self.schedCoroSafe(self.fini())
@s_common.firethread
def finiwaiter():
'''
Wait for the SpawnProc to complete on another thread (so we can block)
'''
self.finievent.wait()
self.todo.put(None)
self.todo.close()
self.done.put(None)
self.done.close()
self.todo.join_thread()
self.done.join_thread()
if self.procstat is None:
try:
self.proc.terminate()
except ValueError:
pass
self.threadpool.shutdown()
# avoid blocking the ioloop during process construction
def getproc():
self.proc = self.mpctx.Process(target=corework,
args=(spawninfo, self.todo,
self.done))
self.proc.start()
await self.executor(getproc)
finiwaiter()
procwaiter()
async def fini():
self.obsolete = True
self.finievent.set()
self.onfini(fini)
def prepare(self):
"""Prepares task for training, populates all derived attributes """
pin_memory = self.use_gpu and torch.cuda.device_count() > 1
self.phases = self._build_phases()
self.train = False if self.test_only else self.train
self.dataloaders = self.build_dataloaders(
current_phase_id=0,
pin_memory=pin_memory,
multiprocessing_context=mp.get_context(self.dataloader_mp_context),
)
if self.batch_norm_sync_mode == BatchNormSyncMode.PYTORCH:
self.base_model = nn.SyncBatchNorm.convert_sync_batchnorm(
self.base_model)
elif self.batch_norm_sync_mode == BatchNormSyncMode.APEX:
sync_bn_process_group = apex.parallel.create_syncbn_process_group(
self.batch_norm_sync_group_size)
self.base_model = apex.parallel.convert_syncbn_model(
self.base_model, process_group=sync_bn_process_group)
# move the model and loss to the right device
if self.use_gpu:
self.base_model, self.loss = copy_model_to_gpu(
self.base_model, self.loss)
else:
self.loss.cpu()
self.base_model.cpu()
if self.optimizer is not None:
self.prepare_optimizer(optimizer=self.optimizer,
model=self.base_model,
loss=self.loss)
if self.amp_args is not None:
# Initialize apex.amp. This updates the model and the PyTorch optimizer (
# if training, which is wrapped by the ClassyOptimizer in self.optimizer).
# Please note this must happen before loading the checkpoint, cause
# there's amp state to be restored.
if self.optimizer is None:
self.base_model = apex.amp.initialize(self.base_model,
optimizers=None,
**self.amp_args)
else:
self.base_model, self.optimizer.optimizer = apex.amp.initialize(
self.base_model, self.optimizer.optimizer, **self.amp_args)
if self.checkpoint_path:
self.checkpoint_dict = load_and_broadcast_checkpoint(
self.checkpoint_path)
classy_state_dict = (None if self.checkpoint_dict is None else
self.checkpoint_dict["classy_state_dict"])
if classy_state_dict is not None:
state_load_success = update_classy_state(self, classy_state_dict)
assert (state_load_success
), "Update classy state from checkpoint was unsuccessful."
self.init_distributed_data_parallel_model()
n_bins = opts.nbins
n_channels = header['channels'][-1]
fs = 2* n_channels * 125e6 / 2048
time_bin_size = 2 * (n_bins) /fs
#might be useful
data_new = {
'pol0' : [],
'pol1' : []
}
print(np.shape(data['pol0']))
## the actual rebinning
##for both pollarizations
with get_context("spawn").Pool() as pool:
for key in ['pol0', 'pol1']:
print("re-binning:", key)
pol = data[key]
##split up the job into lines per core
job = [(np.clip(pol[x:(x+lines_per_core), :],-0.1,0.1), n_bins) for x in range(0,np.shape(pol)[0]-1,lines_per_core)]
##assign the job
result = pool.starmap(spec_resolve, job)
##collaps result
data_new[key] = np.vstack(result)
print(np.shape(data_new['pol0']))
# print 'Data dimensions are:', np.shape(data['pol0']), 'and', np.shape(data['pol1'])
import random
import multiprocessing as mp
import StringMatcher_Interface as smi
def cpu_heavy(x, q):
print('Starting')
print("Done")
if __name__ == '__main__':
procs = 4
jobs = list()
queues = list()
for i in range(0, procs):
ctx = mp.get_context('spawn')
q = ctx.Queue()
process = ctx.Process(target=cpu_heavy, args=('hf', q))
jobs.append(process)
queues.append(q)
for j in jobs:
j.start()
for q in queues:
print(q.get())
for j in jobs:
j.join()
def runModelsChunksSkipMP(self, dataOfInterest, daysToCheck = None, earlyStop=False):
xVals, yVals, yIndex, xToday = self.generateWindows(dataOfInterest)
mpEngine = mp.get_context('fork')
with mpEngine.Manager() as manager:
returnDict = manager.dict()
identifiersToCheck = []
for i in range(len(xVals) - 44): ##44 is lag...should not overlap with any other predictions or will ruin validity of walkforward optimization
if i < 600:
##MIN TRAINING
continue
identifiersToCheck.append(str(i))
if daysToCheck is not None:
identifiersToCheck = identifiersToCheck[-daysToCheck:]
##FIRST CHECK FIRST 500 IDENTIFIERS AND THEN IF GOOD CONTINUE
identifierWindows = [identifiersToCheck[:252], identifiersToCheck[252:600], identifiersToCheck[600:900], identifiersToCheck[900:1200], identifiersToCheck[1200:]] ##EXACTLY TWO YEARS
if earlyStop == False:
identifierWindows = [identifiersToCheck]
returnStream = None
factorReturn = None
predictions = None
slippageAdjustedReturn = None
rawPredictions = None
shortSeen = 0 if earlyStop == True else -1
for clippedIdentifiers in identifierWindows:
splitIdentifiers = np.array_split(np.array(clippedIdentifiers), 4)
runningP = []
k = 0
for identifiers in splitIdentifiers:
p = mpEngine.Process(target=CurvePredictor.runDayChunking, args=(self, xVals, yVals, identifiers, returnDict,k))
p.start()
runningP.append(p)
k += 1
while len(runningP) > 0:
newP = []
for p in runningP:
if p.is_alive() == True:
newP.append(p)
else:
p.join()
runningP = newP
preds = []
actuals = []
days = []
for i in clippedIdentifiers:
preds.append(returnDict[i])
actuals.append(yVals[int(i) + 44])
days.append(yIndex[int(i) + 44])
##CREATE ACCURATE BLENDING ACROSS DAYS
predsTable = pd.DataFrame(preds, index=days, columns=["Predictions"])
i = 1
tablesToJoin = []
while i < self.predictionDistance:
thisTable = predsTable.shift(i)
thisTable.columns = ["Predictions_" + str(i)]
tablesToJoin.append(thisTable)
i += 1
predsTable = predsTable.join(tablesToJoin)
transformedPreds = pd.DataFrame(predsTable.apply(lambda x:dataAck.computePosition(x), axis=1), columns=["Predictions"]).dropna()
dailyFactorReturn = dataAck.getDailyFactorReturn(self.targetTicker, dataOfInterest)
transformedPreds = transformedPreds.join(dailyFactorReturn).dropna()
returnStream = pd.DataFrame(transformedPreds.apply(lambda x:x[0] * x[1], axis=1), columns=["Algo Return"]) if returnStream is None else pd.concat([returnStream, pd.DataFrame(transformedPreds.apply(lambda x:x[0] * x[1], axis=1), columns=["Algo Return"])])
factorReturn = pd.DataFrame(transformedPreds[["Factor Return"]]) if factorReturn is None else pd.concat([factorReturn, pd.DataFrame(transformedPreds[["Factor Return"]])])
predictions = pd.DataFrame(transformedPreds[["Predictions"]]) if predictions is None else pd.concat([predictions, pd.DataFrame(transformedPreds[["Predictions"]])])
rawPredictions = pd.DataFrame(preds, index=days, columns=["Predictions"]) if rawPredictions is None else pd.concat([rawPredictions, pd.DataFrame(preds, index=days, columns=["Predictions"])])
alpha, beta = empyrical.alpha_beta(returnStream, factorReturn)
activity = np.count_nonzero(returnStream)/float(len(returnStream))
rawBeta = abs(empyrical.alpha_beta(returnStream.apply(lambda x:dataAck.applyBinary(x), axis=0), factorReturn.apply(lambda x:dataAck.applyBinary(x), axis=0))[1])
shortSharpe = empyrical.sharpe_ratio(returnStream)
activity = np.count_nonzero(returnStream)/float(len(returnStream))
algoAnnualReturn = empyrical.annual_return(returnStream.values)[0]
algoVol = empyrical.annual_volatility(returnStream.values)
factorAnnualReturn = empyrical.annual_return(factorReturn.values)[0]
factorVol = empyrical.annual_volatility(factorReturn.values)
treynor = ((empyrical.annual_return(returnStream.values)[0] - empyrical.annual_return(factorReturn.values)[0]) \
/ abs(empyrical.beta(returnStream, factorReturn)))
sharpeDiff = empyrical.sharpe_ratio(returnStream) - empyrical.sharpe_ratio(factorReturn)
relativeSharpe = sharpeDiff / empyrical.sharpe_ratio(factorReturn) * (empyrical.sharpe_ratio(factorReturn)/abs(empyrical.sharpe_ratio(factorReturn)))
stability = empyrical.stability_of_timeseries(returnStream)
##CALCULATE SHARPE WITH SLIPPAGE
estimatedSlippageLoss = portfolioGeneration.estimateTransactionCost(predictions)
estimatedSlippageLoss.columns = returnStream.columns
slippageAdjustedReturn = (returnStream - estimatedSlippageLoss).dropna()
slippageSharpe = empyrical.sharpe_ratio(slippageAdjustedReturn)
sharpeDiffSlippage = empyrical.sharpe_ratio(slippageAdjustedReturn) - empyrical.sharpe_ratio(factorReturn)
relativeSharpeSlippage = sharpeDiffSlippage / empyrical.sharpe_ratio(factorReturn) * (empyrical.sharpe_ratio(factorReturn)/abs(empyrical.sharpe_ratio(factorReturn)))
profitability = len((returnStream.values)[returnStream.values > 0])/len(returnStream.values)
rollingProfitability = returnStream.rolling(45, min_periods=45).apply(lambda x:len((x)[x > 0])/len(x)).dropna().values
minRollingProfitability = np.percentile(rollingProfitability, 1)
twentyFifthPercentileRollingProfitablity = np.percentile(rollingProfitability, 25)
if np.isnan(shortSharpe) == True:
return None, {"sharpe":shortSharpe}, None, None, None
elif (profitability < 0.4 or activity < 0.3 or abs(rawBeta) > 0.4 or stability < 0.3) and shortSeen == 0:
return None, {
"sharpe":shortSharpe, ##OVERLOADED IN FAIL
"activity":activity,
"factorSharpe":empyrical.sharpe_ratio(factorReturn),
"sharpeSlippage":slippageSharpe,
"beta":abs(beta),
"alpha":alpha,
"activity":activity,
"treynor":treynor,
"period":"first 252 days",
"algoReturn":algoAnnualReturn,
"algoVol":algoVol,
"factorReturn":factorAnnualReturn,
"factorVol":factorVol,
"sharpeDiff":sharpeDiff,
"relativeSharpe":relativeSharpe,
"sharpeDiffSlippage":sharpeDiffSlippage,
"relativeSharpeSlippage":relativeSharpeSlippage,
"rawBeta":rawBeta,
"minRollingProfitability":minRollingProfitability,
"stability":stability,
"twentyFifthPercentileRollingProfitablity":twentyFifthPercentileRollingProfitablity,
"profitability":profitability
}, None, None, None
elif abs(rawBeta) > 0.33 or activity < 0.3 or stability < 0.4 or twentyFifthPercentileRollingProfitablity < 0.41 \
or minRollingProfitability < 0.3 or profitability < 0.46:
periodName = "first 600 days"
if shortSeen == 2:
periodName = "first 900 days"
elif shortSeen == 3:
periodName = "first 1200 days"
return None, {
"sharpe":shortSharpe, ##OVERLOADED IN FAIL
"activity":activity,
"factorSharpe":empyrical.sharpe_ratio(factorReturn),
"sharpeSlippage":slippageSharpe,
"alpha":alpha,
"beta":abs(beta),
"activity":activity,
"treynor":treynor,
"period":periodName,
"algoReturn":algoAnnualReturn,
"algoVol":algoVol,
"factorReturn":factorAnnualReturn,
"factorVol":factorVol,
"minRollingProfitability":minRollingProfitability,
"sharpeDiff":sharpeDiff,
"relativeSharpe":relativeSharpe,
"sharpeDiffSlippage":sharpeDiffSlippage,
"relativeSharpeSlippage":relativeSharpeSlippage,
"rawBeta":rawBeta,
"stability":stability,
"twentyFifthPercentileRollingProfitablity":twentyFifthPercentileRollingProfitablity,
"profitability":profitability
}, None, None, None
elif shortSeen < 4:
print("CONTINUING", "SHARPE:", shortSharpe, "SHARPE DIFF:", sharpeDiff, "RAW BETA:", rawBeta, "TREYNOR:", treynor)
shortSeen += 1
return returnStream, factorReturn, predictions, slippageAdjustedReturn, rawPredictions
def test_sketch_search_policy_basic_spawn():
ctx = multiprocessing.get_context("spawn")
p = ctx.Process(target=sketch_search_policy_basic_spawn)
p.start()
p.join()
def __init__(self, ctx):
mgr = get_context(ctx).Manager()
self.event = mgr.Event()