예제 #1
0
    def solve(self): #mpp gen

        ts = [t for t in self.terms if t != 1]        

        if self.subset_siz is None:
            subset_siz = len(ts)
        else:
            subset_siz = self.subset_siz
            
        def wprocess(tasks,Q):
            rs = []
            for ts_subset in tasks:
                rs.extend(IeqMPPGen.build_vts_poly(list(ts_subset),self.tcs,self.mpp_opt))

            if Q is None: #no multiprocessing
                return rs
            else:
                Q.put(rs)            

        from vu_common import get_workloads
        tasks = list(itertools.combinations(ts,subset_siz))
        Q = mp.Queue()
        workloads = get_workloads(tasks,max_nprocesses=mp.cpu_count(),
                                  chunksiz=2)

        logger.debug("workloads 'build_vts_poly' {}: {}"
                     .format(len(workloads),map(len,workloads)))
        workers = [mp.Process(target=wprocess,args=(wl,Q))
                   for wl in workloads]

        for w in workers: w.start()
        wrs = []
        for _ in workers: wrs.extend(Q.get())
            
        self.sols = map(InvMPP, wrs)
예제 #2
0
파일: miscs.py 프로젝트: ruricolist/dig
    def runMP(taskname, tasks, wprocess, chunksiz, doMP):
        """
        Run wprocess on tasks in parallel
        """
        if doMP:
            from vu_common import get_workloads
            from multiprocessing import (Process, Queue, cpu_count)
            Q = Queue()
            workloads = get_workloads(tasks,
                                      max_nprocesses=cpu_count(),
                                      chunksiz=chunksiz)

            logger.debug("workloads '{}' {}: {}".format(
                taskname, len(workloads), map(len, workloads)))

            workers = [
                Process(target=wprocess, args=(wl, Q)) for wl in workloads
            ]
            for w in workers:
                w.start()
            wrs = []
            for _ in workers:
                wrs.extend(Q.get())
        else:
            wrs = wprocess(tasks, Q=None)

        return wrs
예제 #3
0
    def rfilter(self, tcs, do_parallel=True):

        if is_empty(self.ps) or is_empty(tcs):
            logger.debug('rfilter skips (|ps|={}, |tcs|={})'.format(
                len(self.ps), len(tcs)))
            return None

        logger.debug('rfilter(|ps|={}, |tcs|={})'.format(
            len(self.ps), len(tcs)))

        if not isinstance(self.ps[0], InvExp):
            from dig_miscs import Miscs
            tcs = Miscs.keys_to_str(tcs)

        def wprocess(tasks, Q):
            rs = [p for p in tasks if all(p.seval(tc) for tc in tcs)]
            if Q is None:  #no multiprocessing
                return rs
            else:
                Q.put(rs)

        tasks = self.ps

        if do_parallel:
            from vu_common import get_workloads
            from multiprocessing import (Process, Queue, current_process,
                                         cpu_count)
            Q = Queue()
            workloads = get_workloads(tasks,
                                      max_nprocesses=cpu_count(),
                                      chunksiz=2)

            logger.debug("workloads 'refine' {}: {}".format(
                len(workloads), map(len, workloads)))

            workers = [
                Process(target=wprocess, args=(wl, Q)) for wl in workloads
            ]

            for w in workers:
                w.start()
            wrs = []
            for _ in workers:
                wrs.extend(Q.get())
        else:
            wrs = wprocess(tasks, Q=None)

        self.ps = wrs
        Refine.print_diff('rfilter', len(tasks), len(self.ps))
예제 #4
0
    def rfilter(self,tcs,do_parallel=True):

        if is_empty(self.ps) or is_empty(tcs):
            logger.debug('rfilter skips (|ps|={}, |tcs|={})'
                         .format(len(self.ps), len(tcs)))
            return None

        logger.debug('rfilter(|ps|={}, |tcs|={})'
                     .format(len(self.ps), len(tcs)))
        
        if not isinstance(self.ps[0],InvExp):
            from dig_miscs import Miscs
            tcs = Miscs.keys_to_str(tcs)

        def wprocess(tasks,Q):
            rs = [p for p in tasks if all(p.seval(tc) for tc in tcs)]
            if Q is None: #no multiprocessing
                return rs
            else:
                Q.put(rs)
            
        tasks = self.ps

        if do_parallel:
            from vu_common import get_workloads
            from multiprocessing import (Process, Queue, 
                                         current_process, cpu_count)
            Q=Queue()
            workloads = get_workloads(tasks, 
                                      max_nprocesses=cpu_count(),
                                      chunksiz=2)

            logger.debug("workloads 'refine' {}: {}"
                         .format(len(workloads),map(len,workloads)))
                                 
            workers = [Process(target=wprocess,args=(wl,Q))
                       for wl in workloads]

            for w in workers: w.start()
            wrs = []
            for _ in workers: wrs.extend(Q.get())
        else:
            wrs = wprocess(tasks,Q=None)
        
        self.ps = wrs
        Refine.print_diff('rfilter', len(tasks), len(self.ps))
예제 #5
0
def tb(src, combs, no_bugfix, no_parallel, no_stop):

    tasks = []
    for sid,tpl,tpl_level, l in combs:
        rs_ = get_data(tpl,l)
        rs_ = [(src, sid, tpl, tpl_level) + r for r in rs_]
        tasks.extend(rs_)

    from random import shuffle
    shuffle(tasks)

    print "KR: tasks {}".format(len(tasks))

    if no_parallel:
        wrs = wprocess(0, tasks, no_stop, no_bugfix, V=None, Q=None)
        
    else: #parallel
        from vu_common import get_workloads
        from multiprocessing import (Process, Queue, Value,
                                     current_process, cpu_count)
        Q = Queue()
        V = Value("i",0)

        workloads = get_workloads(tasks, max_nprocesses=cpu_count(), chunksiz=2)
        print ("workloads {}: {}".format(len(workloads), map(len,workloads)))
               
        workers = [Process(target=wprocess,args=(i,wl,no_stop, no_bugfix, V, Q)) 
                   for i,wl in enumerate(workloads)]

        for w in workers: w.start()
        wrs = []
        for i,_ in enumerate(workers): 
            wrs.extend(Q.get())
        
    wrs = [r for r in wrs if r]
    
    rs = "\n".join(["{}. {}".format(i,r) for i,r in enumerate(wrs)])

    print ("KR: summary "
           "(bugfix: {}, stop after a repair found: {}, parallel: {}), "
           "'{}', {} / {}\n"
           "{}"
           .format(not no_bugfix, not no_stop, not no_parallel, 
                   src,len(wrs),len(tasks),
                   rs))
예제 #6
0
    def solve(self):  #mpp gen

        ts = [t for t in self.terms if t != 1]

        if self.subset_siz is None:
            subset_siz = len(ts)
        else:
            subset_siz = self.subset_siz

        def wprocess(tasks, Q):
            rs = []
            for ts_subset in tasks:
                rs.extend(
                    IeqMPPGen.build_vts_poly(list(ts_subset), self.tcs,
                                             self.mpp_opt))

            if Q is None:  #no multiprocessing
                return rs
            else:
                Q.put(rs)

        from vu_common import get_workloads
        tasks = list(itertools.combinations(ts, subset_siz))
        Q = mp.Queue()
        workloads = get_workloads(tasks,
                                  max_nprocesses=mp.cpu_count(),
                                  chunksiz=2)

        logger.debug("workloads 'build_vts_poly' {}: {}".format(
            len(workloads), map(len, workloads)))
        workers = [
            mp.Process(target=wprocess, args=(wl, Q)) for wl in workloads
        ]

        for w in workers:
            w.start()
        wrs = []
        for _ in workers:
            wrs.extend(Q.get())

        self.sols = map(InvMPP, wrs)
예제 #7
0
파일: kip.py 프로젝트: ruricolist/dig
    def prove_props(self, props, k, do_trans, do_base_case, do_induction,
                    do_pcompress, do_term_check, do_abstraction, nreprove,
                    do_parallel):
        """
        Proves the given properties.
        Attempt to re-prove unproven ones using lemmas.

        do_soft_reprove: checks if the proved properties imply the unknown ones.
        This does not add proved properties as lemmas and re-invoke prover 
        
        nreprove: times we attempt to fully reprove props

        do_parallel performs the task in parallel if 
        multiprocessing is available

        """
        def wprocess(tasks, Q):
            rs = []
            for (idx, p) in tasks:
                logger.info("{}. Checking '{}'".format(idx, p))
                r, m, k_ = self.prove(p,
                                      k=k,
                                      do_base_case=do_base_case,
                                      do_abstraction=do_abstraction,
                                      do_pcompress=do_pcompress,
                                      do_term_check=do_term_check)

                #cannot explicitly store p and m
                #b/c they contain pointers and cannot be pickled
                rs.append((idx, r, m if m is None else model_str(m), k_))

            if Q is None:  #no multiprocessing
                return rs
            else:
                Q.put(rs)

        if do_parallel:
            from vu_common import get_workloads
            from multiprocessing import (Process, Queue, cpu_count)

        nreprove_ = 0
        unchecked_idxs = range(len(props))
        rs = [None] * len(unchecked_idxs)
        while True:

            new_invs = []
            unchecked_idxs_ = []

            tasks = zip(unchecked_idxs, [props[idx] for idx in unchecked_idxs])

            if do_parallel:
                Q = Queue()
                workloads = get_workloads(tasks,
                                          max_nprocesses=cpu_count(),
                                          chunksiz=2)
                logger.debug('workloads {}: {}'.format(len(workloads),
                                                       map(len, workloads)))

                workers = [
                    Process(target=wprocess, args=(wl, Q)) for wl in workloads
                ]

                for w in workers:
                    w.start()
                wrs = []
                for _ in workers:
                    wrs.extend(Q.get())

            else:
                wrs = wprocess(tasks, Q=None)

            for idx, r, m, k_ in wrs:
                p = props[idx]
                #9/10: bug if not make a list copy since these things change!
                rs[idx] = (p, r, m, k_, list(self.invs_state),
                           list(self.assumes_state + self.assumes_trans))

                if r == True:
                    new_invs.append(p)
                if r is None:
                    unchecked_idxs_.append(idx)

            if not (new_invs and unchecked_idxs_):
                break

            if nreprove_ >= nreprove:
                break

            nreprove_ = nreprove_ + 1

            logger.info("Re-prove {} prop(s) using {} new invs "
                        "(attempt {}/{})".format(len(unchecked_idxs_),
                                                 len(new_invs), nreprove_,
                                                 nreprove))

            for inv in new_invs:
                self.add_inv(inv)

            unchecked_idxs = sorted(unchecked_idxs_)

        return rs