diff -urN rt_v30/cg.py rt_v31/cg.py
--- rt_v30/cg.py	2018-04-30 01:48:52.000000000 +0900
+++ rt_v31/cg.py	2018-05-06 14:01:24.000000000 +0900
@@ -13,9 +13,12 @@
 import rt
 import dat
 import img
+import srvs
 
 if __name__ == "__main__":
 
+	srvs.setup()
+
 	dat.setup()
 
 	(w, h) = ( ut.arg_i('w', 640) , ut.arg_i('h', 480) )
diff -urN rt_v30/cmd.py rt_v31/cmd.py
--- rt_v30/cmd.py	2018-05-01 22:13:25.000000000 +0900
+++ rt_v31/cmd.py	2018-05-03 15:43:09.000000000 +0900
@@ -26,13 +26,13 @@
 def func(sock):
 	s = recv_nl(sock)
 	sock.sendall( cmd_exec(s) )
-	#sock.shutdown(socket.SHUT_RDWR)
 	sock.close()
 
 if __name__ == "__main__":
-	port = arg_i('port', 7788)
+	host = '' # all
+	port = arg_i('port', 55510)
 	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
-	sock.bind(('localhost', port))
+	sock.bind((host, port))
 	sock.listen(5)
 
 	while True:
diff -urN rt_v30/cmd_send.py rt_v31/cmd_send.py
--- rt_v30/cmd_send.py	1970-01-01 09:00:00.000000000 +0900
+++ rt_v31/cmd_send.py	2018-05-03 17:43:01.000000000 +0900
@@ -0,0 +1,32 @@
+#!/usr/bin/env python
+
+import sys
+import srvs
+import ut
+
+def get_port(base, i):
+	return srvs.base_port + base + i
+
+if __name__ == "__main__":
+	cmd = 0
+	exp_lst = [1,2] # val, img
+	fwd_lst = [0] + list( range(3,10) )
+
+	lcl_base = 10
+	rmt_host = ut.arg_s('host', '')
+	if not rmt_host:
+		print('host=?')
+		sys.exit(1)
+	rmt_base = ut.arg_i('base', 20)
+
+	f_exp = lambda i: '-R{}:localhost:{}'.format( get_port(lcl_base, i), get_port(lcl_base, i) )
+	opt_exp = ' '.join( map(f_exp, exp_lst) )
+
+	f_fwd = lambda i: '-L{}:localhost:{}'.format( get_port(rmt_base, i), get_port(lcl_base, i) )
+	opt_fwd = ' '.join( map(f_fwd, fwd_lst) )
+
+	rmt_cmd = 'cd /tmp ; tar xf - ; ./cmd.py port={}'.format( get_port(lcl_base, cmd) )
+	cmd = 'tar cf - cmd.py | ssh {} {} {} "{}"'.format(opt_exp, opt_fwd, rmt_host, rmt_cmd)
+	print('cmd="{}"'.format(cmd))
+	ut.cmd_exec(cmd)
+# EOF
diff -urN rt_v30/cross.py rt_v31/cross.py
--- rt_v30/cross.py	2018-04-29 22:19:08.000000000 +0900
+++ rt_v31/cross.py	2018-05-06 14:01:24.000000000 +0900
@@ -295,18 +295,11 @@
 	{ 'cmd': 'cross_', 'func': cross_, 'args': '(line,i4)', 'rets': '(i4,line,xyz,xyz,f8)' },
 ]
 
-sock_inf = {
-	#'srv_cmd': './cross.py boot',
-	'srv_cmd': './cross boot',
-	'port': sock.port + 14,
-	'pid': -1,
-}
-
-cli = sock.new_client(sock_inf, cmd_infs)
+cli = sock.new_client('srv.cross', cmd_infs)
 
 if __name__ == "__main__":
 	if ut.arg_is(1, 'boot'):
-		sock.server(sock_inf, cmd_infs)
+		sock.server('srv.cross', cmd_infs)
 		sys.exit(0)
 
 # EOF
diff -urN rt_v30/img.c rt_v31/img.c
--- rt_v30/img.c	2018-05-01 23:19:45.000000000 +0900
+++ rt_v31/img.c	2018-05-04 00:01:26.000000000 +0900
@@ -15,7 +15,7 @@
 		fd = conn_host_port(host, port);
 	}
 	if(fd < 0){
-		fprintf(stderr, "? val boot\n");
+		fprintf(stderr, "? img boot\n");
 	}
 }
 
diff -urN rt_v30/img.py rt_v31/img.py
--- rt_v30/img.py	2018-04-27 23:50:33.000000000 +0900
+++ rt_v31/img.py	2018-05-06 14:01:24.000000000 +0900
@@ -265,17 +265,11 @@
 	{ 'cmd': 'col', 'func': col, 'args':'(i4,f8,i4,i4,col,(i4,i4))', 'rets':'col' },
 ]
 
-sock_inf = {
-	'srv_cmd': './img.py boot',
-	'port': sock.port + 12,
-	'pid': -1,
-}
-
-cli = sock.new_client(sock_inf, cmd_infs)
+cli = sock.new_client('srv.img', cmd_infs)
 
 if __name__ == "__main__":
 	if ut.arg_is(1, 'boot'):
-		sock.server(sock_inf, cmd_infs)
+		sock.server('srv.img', cmd_infs)
 		sys.exit(0)
 
 	if len(sys.argv[1:]) < 2:
diff -urN rt_v30/kill_str.py rt_v31/kill_str.py
--- rt_v30/kill_str.py	1970-01-01 09:00:00.000000000 +0900
+++ rt_v31/kill_str.py	2018-05-06 14:01:55.000000000 +0900
@@ -0,0 +1,14 @@
+#!/usr/bin/env python
+
+import sys
+
+if __name__ == "__main__":
+	targ = ' '.join( sys.argv[1:] )
+	#print('targ="{}"'.format(targ))
+	if not targ:
+		print('Usage: {} <target>'.format(sys.argv[0]))
+		sys.exit(0)
+
+	s = "ps ax | grep '{}' | grep -v grep | sed 's/^ *//' | cut -d ' ' -f1 | xargs kill"
+	print(s.format(targ))
+# EOF
diff -urN rt_v30/rt.py rt_v31/rt.py
--- rt_v30/rt.py	2018-05-02 00:59:47.000000000 +0900
+++ rt_v31/rt.py	2018-05-06 13:58:26.000000000 +0900
@@ -3,6 +3,7 @@
 import sys
 import math
 import numpy as np
+import threading
 import ut
 import mt
 import v
@@ -155,17 +156,32 @@
 	cnt = ut.new_cnt_wh(w, h, 'wh')
 	sec = video.cur_sec() + ut.arg_f('init_sec', 0.0)
 	show = '-quiet' not in sys.argv
-	while cnt.up(show):
-		(ix, iy) = cnt.cur()
-		p = lstx.tr_p( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) )
-		l_g = line.new_p2(eye2g.p, p)
-
-		col = cli.get_col(l_g, sec, 1.0, -1)
-
-		if col != []:
-			col = np.fmin( col, 255 )
-			video.set(ix, iy, col)
 
+	lock = threading.Lock()
+
+	def func(cli):
+		while True:
+			lock.acquire()
+			run = cnt.up(show)
+			(ix, iy) = cnt.cur()
+			#print('{} {} {}'.format(cli.name, ix, iy))
+			lock.release()
+			if not run:
+				break
+			p = lstx.tr_p( wh2g, 'l2g', mt.arr( [ix,iy,-d_] ) )
+			l_g = line.new_p2(eye2g.p, p)
+
+			col = cli.get_col(l_g, sec, 1.0, -1)
+
+			if col != []:
+				col = np.fmin( col, 255 )
+				lock.acquire()
+				video.set(ix, iy, col)
+				lock.release()
+
+	ths = list( map( lambda cli: ut.th_start( func, cli ), clis ) )
+	for th in ths:
+		th.join()
 ###
 
 cmd_infs = [
@@ -174,17 +190,16 @@
 	{ 'cmd': 'get_col', 'func': get_col, 'args': '(line,f8,f8,i4)', 'rets': 'col' },
 ]
 
-sock_inf = {
-	#'srv_cmd': './rt.py boot',
-	'srv_cmd': './rt boot',
-	'port': sock.port + 13,
-	'pid': -1,
-}
+cli = sock.new_client('srv.rt', cmd_infs)
+
+new_client = lambda name: sock.new_client(name, cmd_infs)
 
-cli = sock.new_client(sock_inf, cmd_infs)
+names = [ 'srv.rt', 'srv.rt-2' ]
+#names = [ 'srv.rt' ]
+clis = list( map( new_client, names ) )
 
 if __name__ == "__main__":
 	if ut.arg_is(1, 'boot'):
-		sock.server(sock_inf, cmd_infs)
+		sock.server('srv.rt', cmd_infs)
 		sys.exit(0)
 # EOF
diff -urN rt_v30/sock.py rt_v31/sock.py
--- rt_v30/sock.py	2018-05-01 01:32:20.000000000 +0900
+++ rt_v31/sock.py	2018-05-06 14:04:03.000000000 +0900
@@ -7,8 +7,6 @@
 import bin
 import pks
 
-port = 55500 # base
-
 def cmd_infs_copy(cmd_infs, typ):
 	args_f = pks.conv_unpack if typ == 'server' else pks.conv_pack
 	rets_f = pks.conv_unpack if typ == 'client' else pks.conv_pack
@@ -23,32 +21,16 @@
 		lst.append(d)
 	return lst
 
-# sock_inf dic keys [ srv_cmd, port, pid ]
-
-def new_client(sock_inf, cmd_infs):
+def new_client(name, cmd_infs):
 	e = ut.Empty()
 
+	e.lock = threading.Lock()
+	e.cond = threading.Condition()
+
 	cmd_infs = cmd_infs_copy(cmd_infs, 'client')
 	cmds = list( map( lambda d: d.get('cmd'), cmd_infs ) )
 	get_cmd_idx = lambda cmd: cmds.index(cmd) if cmd in cmds else -1
 
-	def update_pid():
-		cmd = 'ps ax | grep -v grep | grep "{}"'.format( sock_inf.get('srv_cmd') )
-		s = ut.cmd_exec(cmd)
-		if type(s) == bytes:
-			s = s.decode()
-		s = s.strip().split(' ')[0]
-		pid = int(s) if s else -1
-		sock_inf['pid'] = pid
-	e.update_pid = update_pid
-
-	def boot():
-		proc = ut.cmd_proc( sock_inf.get('srv_cmd') )
-		sock_inf['pid'] = proc.pid
-		ut.sleep(1)
-		print('boot ' + sock_inf.get('srv_cmd'))
-	e.boot = boot
-
 	e.sock = None
 	def new_sock():
 		e.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -56,20 +38,23 @@
 
 	e.conn_ok = False
 	def conn():
-		if sock_inf.get('pid') < 0:
-			update_pid()
-			if sock_inf.get('pid') < 0:
-				boot()
-		if not e.sock:
-			new_sock()
+		import srvs
+		e.cond.acquire()
 		if not e.conn_ok:
+			if not e.sock:
+				new_sock()
 			try:
-				print('conn ' + sock_inf.get('srv_cmd'))
-				port = sock_inf.get('port')
+				port = srvs.get_port(name)
+				ut.prn('conn {} {} ... '.format(name, port))
 				e.sock.connect(('localhost', port))
 				e.conn_ok = True
-			except OSError as err:
-				print('err={}'.format(err))
+				print('ok')
+				e.cond.notify_all()
+			except (OSError, socket.error) as err:
+				print('err')
+				print(err)
+				e.close()
+		e.cond.release()
 	e.conn = conn
 
 	def close():
@@ -83,11 +68,9 @@
 	e.close = close
 
 	def kill():
+		import srvs
 		close()
-		pid = sock_inf.get('pid')
-		if pid >= 0:
-			ut.kill_pid(pid)
-			sock_inf['pid'] = -1
+		srvs.kill(name)
 	e.kill = kill
 
 	read = lambda n: e.sock.recv(n) if n > 0 else ''
@@ -100,6 +83,7 @@
 	send_pks = lambda finf, v: send( pks.pack( finf, v ) )
 
 	def call(cmd, args=None):
+		import srvs
 		i = get_cmd_idx(cmd)
 		if i < 0:
 			ut.err_msg( '? cmd={}'.format(cmd) )
@@ -107,16 +91,26 @@
 		cmd_inf = cmd_infs[i]
 
 		if not e.conn_ok:
+			if name != 'srv.val':
+				srvs.boot(name)
 			e.conn()
+			if not e.conn_ok and name == 'srv.val':
+				srvs.boot(name)
+				e.conn()
+
+		e.lock.acquire()
+
 		try:
 			write( bin.pack_i4(i) )
 		except OSError as err:
-			print(sock_inf)
+			print(name)
 			print(err)
 
 		send_pks( cmd_inf.get('args'), args )
 		(rets, _) = recv_pks( cmd_inf.get('rets') )
 
+		e.lock.release()
+
 		return rets
 	
 	mk_func = lambda cmd: ( lambda *args: call(cmd, args) )
@@ -124,6 +118,8 @@
 	for d in cmd_infs:
 		cmd = d.get('cmd')
 		setattr( e, cmd, mk_func(cmd) )
+
+	e.name = name
 	return e
 
 def cmd_loop(sock, cmd_infs, lock):
@@ -161,18 +157,18 @@
 		sock.shutdown(socket.SHUT_RDWR)
 	sock.close()
 
-def server(sock_inf, cmd_infs):
+def server(name, cmd_infs):
+	import srvs
+
 	lock = threading.Lock()
 	cmd_infs = cmd_infs_copy(cmd_infs, 'server')
 
-	port = sock_inf.get('port')
+	port = srvs.get_port(name)
 	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 	sock.bind(('localhost', port))
 	sock.listen(5)
 
 	while True:
 		(csock, addr) = sock.accept()
-		th = threading.Thread( target=cmd_loop, args=(csock, cmd_infs, lock) )
-		th.daemon = True
-		th.start()
+		ut.th_start(cmd_loop, csock, cmd_infs, lock)
 # EOF
diff -urN rt_v30/sock_test3.py rt_v31/sock_test3.py
--- rt_v30/sock_test3.py	2018-04-25 21:20:00.000000000 +0900
+++ rt_v31/sock_test3.py	2018-05-03 15:41:25.000000000 +0900
@@ -38,9 +38,7 @@
 
 	while True:
 		(csock, addr) = sock.accept()
-		th = threading.Thread( target=srv_f, args=(csock,) )
-		th.daemon = True
-		th.start()
+		ut.th_start(srv_f, csock)
 
 def cli_test(name):
 	sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
@@ -80,9 +78,7 @@
 
 	ths = []
 	for name in [ 'foo', 'bar' ]:
-		th = threading.Thread( target=cli_test, args=(name,) )
-		th.daemon = True
-		th.start()
+		th = ut.th_start(cli_test, name)
 		ths.append(th)
 
 	for th in ths:
diff -urN rt_v30/sock_test4.py rt_v31/sock_test4.py
--- rt_v30/sock_test4.py	2018-04-25 21:30:25.000000000 +0900
+++ rt_v31/sock_test4.py	2018-05-03 15:41:57.000000000 +0900
@@ -55,9 +55,7 @@
 
 	ths = []
 	for name in [ 'foo', 'bar', 'hoge' ]:
-		th = threading.Thread( target=cli_test, args=(name,) )
-		th.daemon = True
-		th.start()
+		th = ut.th_start(cli_test, name)
 		ths.append(th)
 
 	for th in ths:
diff -urN rt_v30/src_send.py rt_v31/src_send.py
--- rt_v30/src_send.py	1970-01-01 09:00:00.000000000 +0900
+++ rt_v31/src_send.py	2018-05-03 21:01:36.000000000 +0900
@@ -0,0 +1,43 @@
+#!/usr/bin/env python
+
+import sys
+import os
+import srvs
+import ut
+
+def get_port(base, i):
+	return srvs.base_port + base + i
+
+if __name__ == "__main__":
+	lcl_base = 10
+	rmt_base = ut.arg_i('base', 20)
+
+	path = ut.arg_s('path', '')
+	if not path:
+		print('path=?')
+		sys.exit(1)
+	(d, n) = os.path.split(path)
+	if not d:
+		d = './'
+	print('d={} n={}'.format(d, n))
+
+	rmt_cmd = 'echo "nc localhost -l {} | tar xf -" | nc localhost {}'.format( get_port(lcl_base, 9), get_port(rmt_base, 0) )
+	print('rmt_cmd={}'.format(rmt_cmd))
+	proc = ut.cmd_proc(rmt_cmd)
+
+	ut.sleep(1)
+
+	lcl_cmd = 'tar cf - -C {} {} | nc localhost {}'.format( d, n, get_port(rmt_base, 9) )
+	print('lcl_cmd={}'.format(lcl_cmd))
+	ut.cmd_exec(lcl_cmd)
+
+	while ut.is_alive(proc):
+		ut.sleep(1)
+		print('wait')
+
+	# build
+	cmd = 'echo "cd {} ; make clean ; make" | nc localhost {}'.format( n, get_port(rmt_base, 0) )
+	print('cmd={}'.format(cmd))
+	ut.cmd_exec(cmd)
+
+# EOF
diff -urN rt_v30/srvs.py rt_v31/srvs.py
--- rt_v30/srvs.py	1970-01-01 09:00:00.000000000 +0900
+++ rt_v31/srvs.py	2018-05-06 13:51:38.000000000 +0900
@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+
+import sys
+import ut
+import val
+
+base_port = 55500
+
+infs = [
+	( 'srv.val', { 'port': base_port + 11, 'cmd': './val.py boot', 'pid': -1 } ),
+	( 'srv.img', { 'port': base_port + 12, 'cmd': './img.py boot', 'pid': -1 } ),
+	( 'srv.rt', { 'port': base_port + 13, 'cmd': './rt boot', 'pid': -1 } ),
+	( 'srv.cross', { 'port': base_port + 14, 'cmd': './cross boot', 'pid': -1 } ),
+
+	( 'srv.rt-2', { 'port': base_port + 23, 'cmd': 'echo "cd rt_v31 ; ./rt boot" | nc localhost {}'.format(base_port + 20), 'pid': -1 } ),
+]
+
+infd = dict(infs)
+
+names = list( zip(*infs) )[0]
+
+def wait_val_conn():
+	val.cli.cond.acquire()
+	while not val.cli.conn_ok:
+		val.cli.cond.wait()
+	val.cli.cond.release()
+
+def boot_conn_val():
+	if val.cli.conn_ok:
+		return
+	val.cli.getn() # dmy for boot srv.val
+	wait_val_conn()
+
+def get_inf_v(name, k):
+	if name not in names:
+		print('srvs.get_inf_v ? ' + name)
+	if name == 'srv.val':
+		if k in ('port', 'cmd'):
+			return infd.get(name).get(k)
+		if not val.cli.conn_ok:
+			return infd.get(name).get(k)
+	boot_conn_val()
+	return val.cli.get_prop(name).get(k)
+
+get_port = lambda name: get_inf_v(name, 'port')
+get_cmd = lambda name: get_inf_v(name, 'cmd')
+get_pid = lambda name: get_inf_v(name, 'pid')
+
+def set_inf(name, inf):
+	if val.cli.conn_ok:
+		typ_str = '{port:i4,cmd:str,pid:i4}'
+		val.cli.set_prop(name, typ_str, inf)
+		return
+	def func():
+		wait_val_conn()
+		set_inf(name, inf)
+	ut.th_start(func)
+
+def set_pid(name, pid):
+	if name not in names:
+		print('srvs.set_pid ? ' + name)
+		return
+	if val.cli.conn_ok:
+		inf = infd.get(name)
+		inf['pid'] = pid
+		set_inf(name, inf)
+		return
+	def func():
+		wait_val_conn()
+		set_pid(name, pid)
+	ut.th_start(func)
+
+def kill(name):
+	if name not in names:
+		print('srvs.kill ? ' + name)
+		return
+	pid = get_pid(name)
+	if pid < 0:
+		return
+	set_pid(name, -1)
+	print('kill {} pid={}'.format(name, pid))
+	ut.kill_pid(pid)
+
+def kill_all():
+	for (name, _) in infs[1:]:
+		kill(name)
+	ut.sleep(2)
+	kill('srv.val')
+
+def boot(name):
+	if name not in names:
+		print('srvs.kill ? ' + name)
+		return
+	if get_pid(name) < 0:
+		cmd = get_cmd(name)
+		print('boot ' + cmd)
+		proc = ut.cmd_proc(cmd)
+		ut.sleep(1)
+		pid = proc.pid
+		set_pid(name, pid)
+
+def setup():
+	boot_conn_val()
+	for (name, inf) in infs[1:]:
+		if not val.cli.has_prop(name):
+			set_inf(name, inf)
+
+if __name__ == "__main__":
+	if ut.arg_is(1, 'kill_all'):
+		setup()
+		kill_all()
+	elif ut.arg_is(1, 'kill'):
+		setup()
+		kill( ut.lst_get(sys.argv, 2, 'srv.val') )
+	elif ut.arg_is(1, 'boot'):
+		setup()
+		boot( ut.lst_get(sys.argv, 2, 'srv.val') )
+	else:
+		print('Usage: {} <cmd>'.format(sys.argv[0]))
+		print('  cmd: kill_all , kill <name> , boot <name>')
+		print('  name: srv.val , srv.img , srv.rt , srv.cross')
+# EOF
diff -urN rt_v30/ut.py rt_v31/ut.py
--- rt_v30/ut.py	2018-04-27 00:43:42.000000000 +0900
+++ rt_v31/ut.py	2018-05-05 17:49:01.000000000 +0900
@@ -6,10 +6,15 @@
 import signal
 import subprocess
 from decimal import *
+import threading
 
 def err_msg(s):
 	sys.stderr.write(s + '\n')
 
+def prn(s):
+	sys.stdout.write(s)
+	sys.stdout.flush()
+
 hex = lambda s: ''.join( map( lambda c: '{:02x}'.format( ord(c) ), s ) )
 
 map_lst = lambda f, lst: list( map( f, lst ) )
@@ -112,6 +117,8 @@
 		return run
 
 	def up(show=True):
+		if e.i >= e.n:
+			return False
 		if not show:
 			return up_no_show()
 		now = now_sec()
@@ -214,4 +221,11 @@
 	if not exists(d):
 		cmd_exec( "mkdir -p '{}'".format(d) )
 
+###
+
+def th_start( func, *args ):
+	th = threading.Thread( target=func, args=args )
+	th.daemon = True
+	th.start()
+	return th
 # EOF
diff -urN rt_v30/val.py rt_v31/val.py
--- rt_v30/val.py	2018-04-30 00:57:42.000000000 +0900
+++ rt_v31/val.py	2018-05-06 14:01:24.000000000 +0900
@@ -145,14 +145,8 @@
 	{ 'cmd': 'get_prop_n_idxs', 'func': get_prop_n_idxs, 'args': '(str,[i4])', 'rets': 'i4' },
 ]
 
-sock_inf = {
-	'srv_cmd': './val.py boot',
-	'port': sock.port + 11,
-	'pid': -1,
-}
-
 def new_client():
-	cli = sock.new_client(sock_inf, cmd_infs)
+	cli = sock.new_client('srv.val', cmd_infs)
 
 	def set_prop(s, typ_str, v):
 		pkd_bytes = pks.pack_org_str(typ_str, v)
@@ -231,7 +225,7 @@
 
 if __name__ == "__main__":
 	if ut.arg_is(1, 'boot'):
-		sock.server(sock_inf, cmd_infs)
+		sock.server('srv.val', cmd_infs)
 		sys.exit(0)
 
 	if ut.arg_is(1, 'tool'):