diff options
| -rw-r--r-- | .hgignore | 2 | ||||
| -rw-r--r-- | src/base/main/main.c | 9 | ||||
| -rw-r--r-- | src/python/getch.py (renamed from scripts/getch.py) | 0 | ||||
| -rw-r--r-- | src/python/pyabc.i | 172 | ||||
| -rw-r--r-- | src/python/pyabc_split.py | 345 | ||||
| -rw-r--r-- | src/python/redirect.py (renamed from scripts/redirect.py) | 0 | ||||
| -rw-r--r-- | src/python/setup.py | 4 |
7 files changed, 468 insertions, 64 deletions
@@ -33,7 +33,7 @@ abcext.dsp src/python/build src/python/bdist src/python/pyabc.py -src.python/pyabc_wrap.* +src/python/pyabc_wrap.* syntax: regexp diff --git a/src/base/main/main.c b/src/base/main/main.c index 42ea255d..0b6294c4 100644 --- a/src/base/main/main.c +++ b/src/base/main/main.c @@ -90,7 +90,14 @@ int Abc_RealMain( int argc, char * argv[] ) init_pyabc(); pModule = PyImport_ImportModule("pyabc"); - Py_DECREF(pModule); + if (pModule) + { + Py_DECREF(pModule); + } + else + { + fprintf( pAbc->Err, "error: pyabc.py not found. PYTHONPATH may not be set properly.\n"); + } } #endif /* ABC_PYTHON_EMBED */ diff --git a/scripts/getch.py b/src/python/getch.py index 89e13078..89e13078 100644 --- a/scripts/getch.py +++ b/src/python/getch.py diff --git a/src/python/pyabc.i b/src/python/pyabc.i index 9dabc3db..56ef5cb0 100644 --- a/src/python/pyabc.i +++ b/src/python/pyabc.i @@ -25,12 +25,8 @@ #include <main.h> #include <stdlib.h> #include <signal.h> - -void sigint_signal_handler(int sig) -{ - _exit(1); -} - +#include <hash.h> +#include <hashPtr.h> int n_ands() { @@ -85,14 +81,6 @@ int n_latches() return -1; } -int run_command(char* cmd) -{ - Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame(); - int fStatus = Cmd_CommandExecute(pAbc, cmd); - - return fStatus; -} - bool has_comb_model() { Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame(); @@ -180,43 +168,99 @@ void pyabc_internal_set_command_callback( PyObject* callback ) Py_XINCREF(callback); Py_XDECREF(pyabc_internal_python_command_callback); - pyabc_internal_python_command_callback = callback; + pyabc_internal_python_command_callback = callback; } static int pyabc_internal_abc_command_callback(Abc_Frame_t * pAbc, int argc, char ** argv) { - int i; - - PyObject* args; - PyObject* arglist; - PyObject* res; - long lres; - - if ( !pyabc_internal_python_command_callback ) - return 0; - - args = PyList_New(argc); - - for( i=0 ; i<argc ; i++ ) - PyList_SetItem(args, i, PyString_FromString(argv[i]) ); - - arglist = Py_BuildValue("(O)", args); - Py_INCREF(arglist); - - res = PyEval_CallObject( pyabc_internal_python_command_callback, arglist ); - Py_DECREF(arglist); - - lres = PyInt_AsLong(res); - Py_DECREF(res); - - return lres; + int i; + + PyObject* args; + PyObject* arglist; + PyObject* res; + + long lres; + + if ( !pyabc_internal_python_command_callback ) + return 0; + + args = PyList_New(argc); + + for( i=0 ; i<argc ; i++ ) + PyList_SetItem(args, i, PyString_FromString(argv[i]) ); + + arglist = Py_BuildValue("(O)", args); + Py_INCREF(arglist); + + res = PyEval_CallObject( pyabc_internal_python_command_callback, arglist ); + Py_DECREF(arglist); + + if ( !res ) + { + return -1; + } + + lres = PyInt_AsLong(res); + Py_DECREF(res); + + return lres; +} + +int run_command(char* cmd) +{ + Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame(); + return Cmd_CommandExecute(pAbc, cmd); } void pyabc_internal_register_command( char * sGroup, char * sName, int fChanges ) { Abc_Frame_t* pAbc = Abc_FrameGetGlobalFrame(); - Cmd_CommandAdd( pAbc, sGroup, sName, (void*)pyabc_internal_abc_command_callback, fChanges); + Cmd_CommandAdd( pAbc, sGroup, sName, (void*)pyabc_internal_abc_command_callback, fChanges); +} + +static Hash_Ptr_t* active_pid_hash = NULL; + +void sigint_handler(int signum) +{ + int i; + Hash_Ptr_Entry_t* pEntry; + + assert( signum == SIGINT ); + + Hash_PtrForEachEntry(active_pid_hash, pEntry, i) + { + int pid = pEntry->key; + kill(pid, SIGINT); + } + + _exit(1); +} + +void add_child_pid(int pid) +{ + Hash_PtrWriteEntry(active_pid_hash, pid, NULL); +} + +void remove_child_pid(int pid) +{ + Hash_PtrRemove(active_pid_hash, pid); +} + +static sigset_t old_procmask; + +void block_sigint() +{ + sigset_t set; + sigemptyset(&set); + sigaddset(&set, SIGINT); + + sigprocmask(SIG_BLOCK, &set, &old_procmask); +} + +void restore_sigint_block() +{ + sigprocmask(SIG_SETMASK, &old_procmask, NULL); } %} @@ -224,7 +268,8 @@ void pyabc_internal_register_command( char * sGroup, char * sName, int fChanges %init %{ Abc_Start(); - signal(SIGINT, sigint_signal_handler); + active_pid_hash = Hash_PtrAlloc(1); + signal(SIGINT, sigint_handler); %} int n_ands(); @@ -252,31 +297,36 @@ int n_phases(); void pyabc_internal_set_command_callback( PyObject* callback ); void pyabc_internal_register_command( char * sGroup, char * sName, int fChanges ); +void block_sigint(); +void restore_sigint_block(); +void add_child_pid(int pid); +void remove_child_pid(int pid); + %pythoncode %{ _registered_commands = {} def _cmd_callback(args): - try: - assert len(args) > 0 - - cmd = args[0] - assert cmd in _registered_commands - - res = _registered_commands[cmd](args) - - assert type(res) == int, "User-defined Python command must return an integer." - - return res - - except Exception, e: - print "Python error: ", e - - except SystemExit, se: - pass - - return 0 + try: + assert len(args) > 0 + + cmd = args[0] + assert cmd in _registered_commands + + res = _registered_commands[cmd](args) + + assert type(res) == int, "User-defined Python command must return an integer." + + return res + + except Exception, e: + print "Python error: ", e + + except SystemExit, se: + pass + + return 0 pyabc_internal_set_command_callback( _cmd_callback ) diff --git a/src/python/pyabc_split.py b/src/python/pyabc_split.py new file mode 100644 index 00000000..b52288c2 --- /dev/null +++ b/src/python/pyabc_split.py @@ -0,0 +1,345 @@ +""" +module pyabc_split + +Executes python functions and their arguements as separate processes and returns their return values through pickling. This modules offers a single function: + +Function: split_all(funcs) + +The function returns a generator objects that allowes iteration over the results, + +Arguments: + +funcs: a list of tuples (f, args) where f is a python function and args is a collection of arguments for f. + +Caveats: + +1. Global variables in the parent process are not affected by the child processes. +2. The functions can only return simple types, see the pickle module for details +3. Signals are currently not handled correctly + +Usage: + +Assume you would like to run the function f_1(1), f_2(1,2), f_3(1,2,3) in different processes. + +def f_1(i): + return i+1 + +def f_2(i,j): + return i*10+j+1 + +def f_3(i,j,k): + return i*100+j*10+k+1 + +Construct a tuple of the function and arguments for each function + +t_1 = (f_1, [1]) +t_2 = (f_2, [1,2]) +t_3 = (f_3, [1,2,3]) + +Create a list containing these tuples: + +funcs = [t_1, t_2, t_3] + +Use the function split_all() to run these functions in separate processes: + +for res in split_all(funcs): + print res + +The output will be: + +2 +13 +124 + +(The order may be different, except that in this case the processes are so fast that they terminate before the next one is created) + +Alternatively, you may quite in the middle, say after the first process returns: + +for res in split_all(funcs): + print res + break + +This will kill all processes not yet finished. + +To run ABC operations, that required saving the child process state and restoring it at the parent, use abc_split_all(). + + import pyabc + + def abc_f(truth): + import os + print "pid=%d, abc_f(%s)"%(os.getpid(), truth) + pyabc.run_command('read_truth %s'%truth) + pyabc.run_command('strash') + + funcs = [ + defer(abc_f)("1000"), + defer(abc_f)("0001") + ] + + for _ in abc_split_all(funcs): + pyabc.run_command('write_verilog /dev/stdout') + +Author: Baruch Sterin <sterin@berkeley.edu> +""" + +import os +import sys +import pickle +import signal +from contextlib import contextmanager + +import pyabc + +class _sigint_critical_section(object): + def __init__(self): + self.blocked = False + + def __enter__(self): + self.acquire() + return self + + def __exit__(self, type, value, traceback): + self.release() + + def acquire(self): + if not self.blocked: + self.blocked = True + pyabc.block_sigint() + + def release(self): + if self.blocked: + self.blocked = False + pyabc.restore_sigint_block() + +class _splitter(object): + + def __init__(self, funcs): + self.funcs = funcs + self.pids = [] + self.fds = {} + self.results = {} + + def is_done(self): + return len(self.fds) == 0 + + def cleanup(self): + + # close pipes and kill child processes + for pid,(i,fd) in self.fds.iteritems(): + os.close(fd) + os.kill( pid, signal.SIGINT ) + + with _sigint_critical_section() as cs: + # wait for termination and update result + for pid, _ in self.fds.iteritems(): + os.waitpid( pid, 0 ) + pyabc.remove_child_pid(pid) + self.results[pid] = None + + self.fds = {} + + def child( self, fdw, f): + # call function + res = f() + + # write return value into pipe + with os.fdopen( fdw, "w" ) as fout: + pickle.dump(res, fout) + + return 0 + + def fork_one(self, f): + + # create a pipe to communicate with the child process + pr,pw = os.pipe() + + parentpid = os.getpid() + rc = 1 + + try: + + with _sigint_critical_section() as cs: + # create child process + pid = os.fork() + + if pid == 0: + # child process: + cs.release() + os.close(pr) + rc = self.child( pw, f) + os._exit(rc) + else: + # parent process: + pyabc.add_child_pid(pid) + os.close(pw) + return (pid, pr) + + finally: + if os.getpid() != parentpid: + os._exit(rc) + + def fork_all(self): + for i,f in enumerate(self.funcs): + pid, fd = self.fork_one(f) + self.pids.append(pid) + self.fds[pid] = (i,fd) + + def get_next_result(self): + + # wait for the next child process to terminate + pid, rc = os.wait() + assert pid in self.fds + + # retrieve the pipe file descriptor1 + i, fd = self.fds[pid] + del self.fds[pid] + + assert pid not in self.fds + + # read result from file + with os.fdopen( fd, "r" ) as fin: + try: + return (i,pickle.load(fin)) + except EOFError, pickle.UnpicklingError: + return (i, None) + +@contextmanager +def _splitter_wrapper(funcs): + # ensure cleanup of child processes + s = _splitter(funcs) + try: + yield s + finally: + s.cleanup() + +def split_all_full(funcs): + # provide an iterator for child process result + with _splitter_wrapper(funcs) as s: + + s.fork_all() + + while not s.is_done(): + yield s.get_next_result() + +def defer(f): + return lambda *args, **kwargs: lambda : f(*args,**kwargs) + +def split_all(funcs): + for _, res in split_all_full( ( defer(f)(*args) for f,args in funcs ) ): + yield res + +import tempfile + +@contextmanager +def temp_file_names(suffixes): + names = [] + try: + for suffix in suffixes: + with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as file: + names.append( file.name ) + yield names + finally: + for name in names: + os.unlink(name) + +class abc_state(object): + def __init__(self): + with tempfile.NamedTemporaryFile(delete=False, suffix='.aig') as file: + self.aig = file.name + with tempfile.NamedTemporaryFile(delete=False, suffix='.log') as file: + self.log = file.name + pyabc.run_command(r'write_status %s'%self.log) + pyabc.run_command(r'write_aiger %s'%self.aig) + + def __del__(self): + os.unlink( self.aig ) + os.unlink( self.log ) + + def restore(self): + pyabc.run_command(r'read_aiger %s'%self.aig) + pyabc.run_command(r'read_status %s'%self.log) + +def abc_split_all(funcs): + import pyabc + + def child(f, aig, log): + res = f() + pyabc.run_command(r'write_status %s'%log) + pyabc.run_command(r'write_aiger %s'%aig) + return res + + def parent(res, aig, log): + pyabc.run_command(r'read_aiger %s'%aig) + pyabc.run_command(r'read_status %s'%log) + return res + + with temp_file_names( ['.aig','.log']*len(funcs) ) as tmp: + + funcs = [ defer(child)(f, tmp[2*i],tmp[2*i+1]) for i,f in enumerate(funcs) ] + + for i, res in split_all_full(funcs): + yield i, parent(res, tmp[2*i],tmp[2*i+1]) + +if __name__ == "__main__": + + # define some functions to run + + def f_1(i): + return i+1 + + def f_2(i,j): + return i*10+j+1 + + def f_3(i,j,k): + return i*100+j*10+k+1 + + # Construct a tuple of the function and arguments for each function + + t_1 = (f_1, [1]) + t_2 = (f_2, [1,2]) + t_3 = (f_3, [1,2,3]) + + # Create a list containing these tuples: + + funcs = [t_1, t_2, t_3] + + # Use the function split_all() to run these functions in separate processes: + + for res in split_all(funcs): + print res + + # Alternatively, quit after the first process returns: + + for res in split_all(funcs): + print res + break + + # For operations with ABC that save and restore status + + import pyabc + + def abc_f(truth): + import os + print "pid=%d, abc_f(%s)"%(os.getpid(), truth) + pyabc.run_command('read_truth %s'%truth) + pyabc.run_command('strash') + return 100 + + funcs = [ + defer(abc_f)("1000"), + defer(abc_f)("0001") + ] + + best = None + + for i, res in abc_split_all(funcs): + print i, res + if best is None:\ + # save state + best = abc_state() + pyabc.run_command('write_verilog /dev/stdout') + + # if there is a saved state, restore it + if best is not None: + best.restore() + pyabc.run_command('write_verilog /dev/stdout') diff --git a/scripts/redirect.py b/src/python/redirect.py index 498fe150..498fe150 100644 --- a/scripts/redirect.py +++ b/src/python/redirect.py diff --git a/src/python/setup.py b/src/python/setup.py index abc07afa..a832f511 100644 --- a/src/python/setup.py +++ b/src/python/setup.py @@ -6,6 +6,7 @@ from distutils import util include_dirs = [ '../aig/hop', + '../aig/gia', '../base/abc', '../base/cmd', '../base/io', @@ -18,6 +19,7 @@ include_dirs = [ '../misc/st', '../misc/util', '../misc/vec', + '../misc/hash', ] define_macros = [] @@ -60,5 +62,5 @@ setup( name='pyabc', version='1.0', ext_modules=[ext], - py_modules=['pyabc'] + py_modules=['pyabc','getch','pyabc_split','redirect'] ) |