Ejemplo n.º 1
0
    def __init__(self):

        super(FSM, self).__init__(show_conditions=True,
                                  auto_transitions=False,
                                  title="Projected GUI state machine")

        states = [
            'initial', 'calibrate_projectors', 'waiting_for_user',
            'waiting_for_user_calibration', 'program_selection', 'learning',
            'running'
        ]

        self.add_states(states)

        logger.setLevel(logging.DEBUG)

        # trigger, source, destination
        self.add_transition('tr_start',
                            'initial',
                            'calibrate_projectors',
                            after='cb_start_calibration')
        self.add_transition('tr_projectors_calibrated',
                            'calibrate_projectors',
                            'waiting_for_user',
                            after='cb_waiting_for_user')
        self.add_transition('tr_projectors_calibrated',
                            'initial',
                            'waiting_for_user',
                            after='cb_waiting_for_user')
        self.add_transition('tr_user_present',
                            'waiting_for_user',
                            'waiting_for_user_calibration',
                            after="cb_waiting_for_user_calibration")
        self.add_transition('tr_user_calibrated',
                            'waiting_for_user_calibration',
                            'program_selection',
                            after='cb_program_selection')
        self.add_transition('tr_program_edit',
                            'program_selection',
                            'learning',
                            after="cb_learning")
        self.add_transition('tr_program_selected',
                            'program_selection',
                            'running',
                            after="cb_running")
        self.add_transition('tr_program_learned',
                            'learning',
                            'program_selection',
                            after='cb_program_selection')
        self.add_transition('tr_running', '*', 'running', after="cb_running")
        self.add_transition('tr_program_finished',
                            'running',
                            'program_selection',
                            after='cb_program_selection')
Ejemplo n.º 2
0
    def __init__(self):

        super(FSM, self).__init__(show_conditions=True, auto_transitions=False, title="Projected GUI state machine")

        states = ['initial', 'calibrate', 'waiting_for_user', 'waiting_for_user_calibration', 'program_selection', 'learning', 'running']

        self.add_states(states)

        logger.setLevel(logging.DEBUG)

        # trigger, source, destination
        self.add_transition('tr_start', 'initial', 'calibrate', after='cb_start_calibration')
        self.add_transition('tr_calibrated', 'calibrate', 'waiting_for_user', after='cb_waiting_for_user')
        self.add_transition('tr_user_present', 'waiting_for_user', 'waiting_for_user_calibration', after="cb_waiting_for_user_calibration")
        self.add_transition('tr_user_calibrated', 'waiting_for_user_calibration', 'program_selection', after='cb_program_selection')
        self.add_transition('tr_program_selected', 'program_selection', 'learning', conditions='is_template', after="cb_learning")
        self.add_transition('tr_program_selected', 'program_selection', 'running', unless='is_template')
        self.add_transition('tr_program_learned', 'learning', 'running', after="cb_running")
        self.add_transition('tr_running', '*', 'running', after="cb_running")
def log2yaml(filename, presvec):
    # construct the YAML string
    # 2nd version, using FSM (Finite State Machine)
    states = ['none', 'transient', 'nonlinear', 'linear', 'l_setup', 'l_solutiontime', 'l_iteration']
    transitions = [
        { 'trigger': 'n2t',              'source': 'none',                        'dest': 'transient'  },
        { 'trigger': 't2n',              'source': 'transient',                   'dest': 'none'       },
        { 'trigger': 't2nl',             'source': 'transient',                   'dest': 'nonlinear'  },
        { 'trigger': 'nl2t',             'source': 'nonlinear',                   'dest': 'transient'  },
        { 'trigger': 'nl2l',             'source': 'nonlinear',                   'dest': 'linear'     },
        { 'trigger': 'l2l_setup',        'source': 'linear',                      'dest': 'l_setup'    },
        { 'trigger': 'l_setup2l',        'source': 'l_setup',                     'dest': 'linear'     },
        { 'trigger': 'l2l_solutiontime', 'source': 'linear',                      'dest': 'l_solutiontime'    },
        { 'trigger': 'l_solutiontime2l_iteration', 'source': 'l_solutiontime',    'dest': 'l_iteration'},        
        { 'trigger': 'l_iteration2t',    'source': 'l_iteration',                 'dest': 'transient'  },
        { 'trigger': 'n2nl',             'source': 'none',                        'dest': 'nonlinear'  },
        { 'trigger': 'n2l_setup',        'source': 'none',                        'dest': 'l_setup'  }
    ]

    logger.setLevel(logging.INFO)

    machine = Drekar()
    M = Machine(model=machine, states=states, transitions=transitions, initial='none')

    mode = 'drekar'
    start_stepper                   = 'Entering Rythmos::.*::advanceStepperToTime'
    end_stepper                     = 'Leaving Rythmos::.*::advanceStepperToTime'
    start_c_step                    = 'Entering Rythmos::.*::takeStep'
    end_c_step                      = 'Leaving Rythmos::.*::takeStep'
    start_nl_step                   = '(?<=Nonlinear Solver Step )\d*'
    end_nl_step_good                = '\(Converged!\)'
    end_nl_step_bad                 = '\(Failed!\)'
    start_l_step                    = 'CALCULATING FORCING TERM'
    start_residual_aztecoo          = 'Problem: Thyra::DefaultBlockedLinearOp'
    start_setuptime                 = '(?<=TimeMonitor results over )\d*'
    end_setuptime                   = '(?<=MueLu setup time )\d*'
    end_simulation                  = '(?<=Drekar run completed.)'
    start_solutiontime              = '(?<=Solution time: ).*(?= \(sec.\))'
    end_l_step                      = '(?<=total iterations: )\d*'
    close_file                      = 'CLOSEFILE'
    
    #end_residual_belos_good         = '(?<=returned a solve status of "SOLVE_STATUS_CONVERGED" in )\d*'
    #end_residual_belos_bad          = '(?<=returned a solve status of "SOLVE_STATUS_UNCONVERGED" in )\d*'
    
    #mid_timers                      = '.* \(.*\)\s*$'
    #end_timers                      = '==========='

    timer_names  = []
    timer_times  = {}
    timer_calls  = {}
    timer_serial = None

    nl_step = 0
    t_step  = 0
    lineno  = 0
    
    l_setuptimes = []

    cur_setup_time = 0.0

    yaml_string = '{"scheme":"' + mode + '","Steps":{'
    with open(filename) as f:
        try:
            for line in f:
                lineno += 1
                if   re.search(start_stepper, line) != None:
                    if machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    t_step  = 0
                    
                elif re.search(end_stepper, line) != None:
                    if machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)

                elif re.search(start_c_step, line) != None:
                    if machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    machine.n2t()

                    if yaml_string[-1] != '{':
                        yaml_string += ','
                    yaml_string += '"c_step_' + str(t_step) + '":{'

                elif re.search(end_c_step, line) != None:
                    if machine.state != 'transient':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    machine.t2n()

                    yaml_string += ', "nl_its":' + str(nl_step-1) + '}'

                    nl_step  = 0
                    t_step  += 1
                
                # start NONLINEAR state
                elif re.search(start_nl_step, line) != None:
		    print 'start nonlinear state...'
                    if machine.state != 'transient' and machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    
                    if machine.state == 'none':
		      machine.n2nl()
                    elif machine.state == 'transient':
		      machine.t2nl()
		    

                    if yaml_string[-1] != '{':
                        yaml_string += ','
                    yaml_string += '"nl_step_' + str(nl_step) + '":{'

                    nl_step += 1
                    
                elif re.search(end_nl_step_good, line) != None or re.search(end_nl_step_bad, line) != None:
		    print 'end nonlinear state...'
                    if machine.state != 'nonlinear':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    machine.nl2t()

		    print yaml_string

                    # Get rid of ",nl_step_?:{}
                    i = 1
                    while (yaml_string[-i] != ','):
                         i += 1
                    yaml_string = yaml_string[:-i]
              
                    print yaml_string
                # start LINEAR state
                elif re.search(start_l_step, line) != None:
		    print 'start linear state...'
                    if machine.state != 'nonlinear':
                        raise RuntimeError('Wrong state: ' + machine.state)
		    machine.nl2l()

		    l_setuptimes[:] = [] # empty list of setup times
		    	    
                # Collect setup time data for MueLu             
                elif re.search(start_setuptime, line) != None:
		    print 'collect setup time...'
		    if machine.state == 'none' or machine.state == 'transient':
			continue
                    if machine.state != 'linear' and machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
		      
		    machine.l2l_setup()

		elif re.search(end_setuptime, line) != None:
		    print 'collect setup time done...'
                    if machine.state != 'l_setup':
                        raise RuntimeError('Wrong state: ' + machine.state)
		                   
                    m = re.search(end_setuptime, line)
                    if m != None:
                        tt = m.group()
                    else:
                        m = re.search(end_timers_aztecoo, line)
                        tt = m.group()
                    cur_setup_time = line.split(" ")[6]
                    
                    l_setuptimes.append(float(cur_setup_time))
                    
                    machine.l_setup2l()

		# extract linear solution time
                elif re.search(start_solutiontime, line) != None:
		    print 'extract solution time...'
                    if machine.state != 'linear':
                        raise RuntimeError('Wrong state: ' + machine.state)

		    machine.l2l_solutiontime()
		    
                    m = re.search(start_solutiontime, line)
                    tt = m.group()
                    yaml_string += '  "solve_time":' + str(tt)   
                   
                    machine.l_solutiontime2l_iteration()

		# extract linear iterations
		# end LINEAR state
                elif re.search(end_l_step, line) != None:
		    print 'extract iterations...'
                    if machine.state != 'l_iteration':
                        raise RuntimeError('Wrong state: ' + machine.state)

                    m = re.search(end_l_step, line)
                    tt = m.group()
                    yaml_string += ', "its":' + str(tt)   
                   
		    yaml_string += ', "setup_time":' + str(sum(l_setuptimes)) + '}'
		    l_setuptimes[:] = []
                   
                    machine.l_iteration2t()                             
                    print 'end linear state...'
                elif re.search(end_simulation, line) != None:
		  
		    print 'end simulation'
		    
                elif re.search(close_file, line) != None:
		    if machine.state == 'linear':
			yaml_string += ' "its": -1' + ' }'
                        machine.l2t()
                       
		    if machine.state == 'nonlinear':
                        machine.nl2t()

			# Get rid of ",nl_step_?:{}
			i = 1
			while (yaml_string[-i] != ','):
			    i += 1
			yaml_string = yaml_string[:-i]
                    
                    if machine.state == 'transient':
		      	i = 1
			while (yaml_string[-i] != ','):
			    i += 1
			yaml_string = yaml_string[:-i]
			yaml_string += ', "nl_its":' + str(nl_step) + '}'
			nl_step  = 0
			machine.t2n()

		  
        except RuntimeError as e:
            raise RuntimeError("Caught an error while parsing on line " + str(lineno) + ": " + e.args[0])

    if timer_serial == None:
        # We did not encounter any timers
        yaml_string += '}}'

    print yaml_string
    print yaml.load(yaml_string)

    try:
        yaml_data = yaml.load(yaml_string)
    except yaml.parser.ParserError:
        raise RuntimeError('Could not parse YAML out. Did you select the right mode?')

    
    return yaml_data
Ejemplo n.º 4
0
    def run(self, filename):
        """We skip all timer outputs until the last one"""
        logger.setLevel(logging.DEBUG)

        machine = self
        M = Machine(model=machine,
                    states=self.states,
                    transitions=self.transitions,
                    initial='none')

        # construct the YAML string
        start_residual = '\*\*\*\*\* Belos Iterative Solver: '
        mid_residual = 'Iter.*, \[.*\] :\s*.*'
        end_residual = '(?<=Number of iterations performed for this solve: )\d*'
        start_timers = '(?<=TimeMonitor results over )\d*'
        mid_timers = '.* \(.*\)\s*$'
        end_timers = '==========='

        nprocs = -1
        timer_names = []
        timer_times = {}
        timer_calls = {}
        timer_serial = None

        through_residual = False

        yaml_string = '{"scheme":"muelu","Steps":{"c_step_0":{"nl_step_0":{'
        with open(filename) as f:
            try:
                for line in f:
                    if re.search(start_residual, line) != None:
                        if machine.state != 'none':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.n2r()

                        through_residual = True

                        if yaml_string[-1] != '{':
                            yaml_string += ','
                        yaml_string += '"res_hist":['

                    elif re.search(mid_residual, line) != None:
                        if machine.state != 'residual':
                            raise RuntimeError('Wrong state: ' + machine.state)

                        m = re.search('[^\s]*$', line)
                        res = m.group()
                        if yaml_string[-1] != '[':
                            yaml_string += ','
                        yaml_string += res

                    elif re.search(end_residual, line) != None:
                        if machine.state != 'residual':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.r2n()

                        m = re.search(end_residual, line)
                        its = m.group()
                        yaml_string += '], "its":' + its + '}}'

                    elif re.search(start_timers, line) != None:
                        if machine.state != 'none':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.n2t()

                        # Reset timers
                        timer_names = []
                        timer_times = {}
                        timer_calls = {}

                        m = re.search(start_timers, line)
                        nprocs = m.group()

                        if nprocs == "1":
                            timer_serial = True
                        else:
                            timer_serial = False

                    elif re.search(end_timers, line) != None:
                        if machine.state != 'timers':
                            # there could be other ======== lines
                            continue
                        machine.t2n()

                    elif re.search(mid_timers, line) != None:
                        if machine.state != 'timers':
                            # there could be other matching lines
                            continue

                        if re.search('Timer Name', line) != None:
                            # Skip header (in serial it matches the pattern)
                            continue

                        splits = line.split()
                        if timer_serial == True:
                            name = ' '.join(splits[0:-2])
                            name = name.replace('"', '\\"')
                            timer_names.append(name)
                            timer_times[name] = {}
                            timer_times[name]['MinOverProcs'] = splits[-2]
                            timer_times[name]['MeanOverProcs'] = splits[-2]
                            timer_times[name]['MaxOverProcs'] = splits[-2]
                            timer_times[name]['MeanOverCallCounts'] = splits[
                                -2]
                            timer_calls[name] = {}
                            timer_calls[name]['MinOverProcs'] = splits[-1][
                                1:-1]
                            timer_calls[name]['MeanOverProcs'] = splits[-1][
                                1:-1]
                            timer_calls[name]['MaxOverProcs'] = splits[-1][
                                1:-1]
                            timer_calls[name]['MeanOverCallCounts'] = splits[
                                -1][1:-1]
                        else:
                            name = ' '.join(splits[0:-8])
                            name = name.replace('"', '\\"')
                            timer_names.append(name)
                            timer_times[name] = {}
                            timer_times[name]['MinOverProcs'] = splits[-8]
                            timer_times[name]['MeanOverProcs'] = splits[-6]
                            timer_times[name]['MaxOverProcs'] = splits[-4]
                            timer_times[name]['MeanOverCallCounts'] = splits[
                                -2]
                            timer_calls[name] = {}
                            timer_calls[name]['MinOverProcs'] = splits[-7][
                                1:-1]
                            timer_calls[name]['MeanOverProcs'] = splits[-5][
                                1:-1]
                            timer_calls[name]['MaxOverProcs'] = splits[-3][
                                1:-1]
                            timer_calls[name]['MeanOverCallCounts'] = splits[
                                -1][1:-1]

                if not through_residual:
                    # Somebody may have given a truncated log with
                    # just timers
                    yaml_string += '"res_hist":[], "its":0}}'

                if not timer_serial == None:
                    # We did encounter some timers

                    # Finalize stepping
                    yaml_string += '}'

                    yaml_string += ',"Number of processes":' + nprocs
                    yaml_string += ',"Time unit":s'
                    yaml_string += ',"Statistics collected":["MinOverProcs","MeanOverProcs","MaxOverProcs","MeanOverCallCounts"]'

                    # Timer names
                    yaml_string += ',"Timer names":['
                    for name in timer_names:
                        if yaml_string[-1] != '[':
                            yaml_string += ','
                        yaml_string += '"' + name + '"'
                    yaml_string += ']'

                    # Total times
                    yaml_string += ',"Total times":{'
                    for name in timer_names:
                        if yaml_string[-1] != '{':
                            yaml_string += ','
                        yaml_string += '"' + name + '":{'
                        yaml_string += '"MinOverProcs":' + timer_times[name][
                            'MinOverProcs']
                        yaml_string += ',"MeanOverProcs":' + timer_times[name][
                            'MeanOverProcs']
                        yaml_string += ',"MaxOverProcs":' + timer_times[name][
                            'MaxOverProcs']
                        yaml_string += ',"MeanOverCallCounts":' + timer_times[
                            name]['MeanOverCallCounts']
                        yaml_string += '}'
                    yaml_string += '}'

                    # Call counts
                    yaml_string += ',"Call counts":{'
                    for name in timer_calls:
                        if yaml_string[-1] != '{':
                            yaml_string += ','
                        yaml_string += '"' + name + '":{'
                        yaml_string += '"MinOverProcs":' + timer_times[name][
                            'MinOverProcs']
                        yaml_string += ',"MeanOverProcs":' + timer_times[name][
                            'MeanOverProcs']
                        yaml_string += ',"MaxOverProcs":' + timer_times[name][
                            'MaxOverProcs']
                        yaml_string += ',"MeanOverCallCounts":' + timer_times[
                            name]['MeanOverCallCounts']
                        yaml_string += '}'
                    yaml_string += '}'

                    yaml_string += '}'

            except RuntimeError as e:
                raise RuntimeError("Caught an error while parsing on line " +
                                   str(lineno) + ": " + e.args[0])

        if timer_serial == None:
            # We did not encounter any timers
            yaml_string += '}}'

        try:
            yaml_data = yaml.load(yaml_string)
        except yaml.parser.ParserError:
            print('Badly formatted YAML string:\n', yaml_string)
            raise RuntimeError('Did you select the right mode?')

        return yaml_data
Ejemplo n.º 5
0
    def run(self, filename):
        logger.setLevel(logging.INFO)

        machine = self
        M = Machine(model=machine,
                    states=self.states,
                    transitions=self.transitions,
                    initial='none')

        start_stepper = 'Entering Rythmos::.*::advanceStepperToTime'
        end_stepper = 'Leaving Rythmos::.*::advanceStepperToTime'
        start_c_step = 'Entering Rythmos::.*::takeStep'
        end_c_step = 'Leaving Rythmos::.*::takeStep'
        start_nl_step = '(?<=Nonlinear Solver Step )\d*'
        end_nl_step_good = '\(Converged!\)'
        end_nl_step_bad = '\(Failed!\)'
        start_residual_belos = '\*\*\*\*\* Belos Iterative Solver: '
        mid_residual = 'Iter.*, \[.*\] :\s*.*'
        end_residual_belos_good = '(?<=returned a solve status of "SOLVE_STATUS_CONVERGED" in )\d*'
        end_residual_belos_bad = '(?<=returned a solve status of "SOLVE_STATUS_UNCONVERGED" in )\d*'
        start_timers = '(?<=TimeMonitor results over )\d*'
        mid_timers = '.* \(.*\)\s*$'
        end_timers = '==========='

        timer_names = []
        timer_times = {}
        timer_calls = {}
        timer_serial = None

        nl_step = 0
        t_step = 0
        lineno = 0

        yaml_string = '{"scheme":"drekar","Steps":{'
        with open(filename) as f:
            try:
                for line in f:
                    lineno += 1
                    if re.search(start_stepper, line) != None:
                        if machine.state != 'none':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        t_step = 0

                    elif re.search(end_stepper, line) != None:
                        if machine.state != 'none':
                            raise RuntimeError('Wrong state: ' + machine.state)

                    elif re.search(start_c_step, line) != None:
                        if machine.state != 'none':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.n2t()

                        if yaml_string[-1] != '{':
                            yaml_string += ','
                        yaml_string += '"c_step_' + str(t_step) + '":{'

                    elif re.search(end_c_step, line) != None:
                        if machine.state != 'transient':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.t2n()

                        yaml_string += ', "nl_its":' + str(nl_step) + '}'

                        nl_step = 0
                        t_step += 1

                    elif re.search(start_nl_step, line) != None:
                        if machine.state != 'transient':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.t2nl()

                        if yaml_string[-1] != '{':
                            yaml_string += ','
                        yaml_string += '"nl_step_' + str(nl_step) + '":{'

                        nl_step += 1

                    elif re.search(end_nl_step_good,
                                   line) != None or re.search(
                                       end_nl_step_bad, line) != None:
                        if machine.state != 'nonlinear':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.nl2t()

                        # Get rid of ",nl_step_?:{}
                        i = 1
                        while (yaml_string[-i] != ','):
                            i += 1
                        yaml_string = yaml_string[:-i]

                    elif re.search(start_residual_belos, line) != None:
                        if machine.state != 'nonlinear':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.nl2l()

                        if yaml_string[-1] != '{':
                            yaml_string += ','
                        yaml_string += '"res_hist":['

                    elif re.search(end_residual_belos_good,
                                   line) != None or re.search(
                                       end_residual_belos_bad, line) != None:
                        if machine.state != 'linear':
                            raise RuntimeError('Wrong state: ' + machine.state)

                        machine.l2t()

                        m = re.search(end_residual_belos_good, line)
                        if m != None:
                            its = m.group()
                        else:
                            m = re.search(end_residual_belos_bad, line)
                            its = m.group()
                        yaml_string += '], "its":' + its

                        m = re.search(
                            '(?<=with total CPU time of ).*(?=\ sec)', line)
                        belos_time = m.group()
                        yaml_string += ', "solve_time":' + belos_time + '}'

                    elif re.search(mid_residual, line) != None:
                        if machine.state != 'linear':
                            raise RuntimeError('Wrong state: ' + machine.state)

                        m = re.search('[^\s]*$', line)
                        res = m.group()
                        if yaml_string[-1] != '[':
                            yaml_string += ','
                        yaml_string += res

                    elif re.search(start_timers, line) != None:
                        if machine.state != 'none':
                            raise RuntimeError('Wrong state: ' + machine.state)
                        machine.n2m()

                        m = re.search(start_timers, line)
                        nprocs = m.group()

                        if nprocs == "1":
                            timer_serial = True
                        else:
                            timer_serial = False

                        # Finalize stepping
                        yaml_string += '}'

                        yaml_string += ',"Number of processes":' + nprocs
                        yaml_string += ',"Time unit":s'
                        yaml_string += ',"Statistics collected":["MinOverProcs","MeanOverProcs","MaxOverProcs","MeanOverCallCounts"]'

                    elif re.search(end_timers, line) != None:
                        if machine.state != 'timers':
                            # there could be other ======== lines
                            continue
                        machine.m2n()

                        # Timer names
                        yaml_string += ',"Timer names":['
                        for name in timer_names:
                            if yaml_string[-1] != '[':
                                yaml_string += ','
                            yaml_string += '"' + name + '"'
                        yaml_string += ']'

                        # Total times
                        yaml_string += ',"Total times":{'
                        for name in timer_names:
                            if yaml_string[-1] != '{':
                                yaml_string += ','
                            yaml_string += '"' + name + '":{'
                            yaml_string += '"MinOverProcs":' + timer_times[
                                name]['MinOverProcs']
                            yaml_string += ',"MeanOverProcs":' + timer_times[
                                name]['MeanOverProcs']
                            yaml_string += ',"MaxOverProcs":' + timer_times[
                                name]['MaxOverProcs']
                            yaml_string += ',"MeanOverCallCounts":' + timer_times[
                                name]['MeanOverCallCounts']
                            yaml_string += '}'
                        yaml_string += '}'

                        # Call counts
                        yaml_string += ',"Call counts":{'
                        for name in timer_calls:
                            if yaml_string[-1] != '{':
                                yaml_string += ','
                            yaml_string += '"' + name + '":{'
                            yaml_string += '"MinOverProcs":' + timer_times[
                                name]['MinOverProcs']
                            yaml_string += ',"MeanOverProcs":' + timer_times[
                                name]['MeanOverProcs']
                            yaml_string += ',"MaxOverProcs":' + timer_times[
                                name]['MaxOverProcs']
                            yaml_string += ',"MeanOverCallCounts":' + timer_times[
                                name]['MeanOverCallCounts']
                            yaml_string += '}'
                        yaml_string += '}'

                        yaml_string += '}'

                    elif re.search(mid_timers, line) != None:
                        if machine.state != 'timers':
                            # there could be other matching lines
                            continue

                        if re.search('Timer Name', line) != None:
                            # Skip header (in serial it matches the pattern)
                            continue

                        splits = line.split()
                        if timer_serial == True:
                            name = ' '.join(splits[0:-2])
                            name = name.replace('"', '\\"')
                            timer_names.append(name)
                            timer_times[name] = {}
                            timer_times[name]['MinOverProcs'] = splits[-2]
                            timer_times[name]['MeanOverProcs'] = splits[-2]
                            timer_times[name]['MaxOverProcs'] = splits[-2]
                            timer_times[name]['MeanOverCallCounts'] = splits[
                                -2]
                            timer_calls[name] = {}
                            timer_calls[name]['MinOverProcs'] = splits[-1][
                                1:-1]
                            timer_calls[name]['MeanOverProcs'] = splits[-1][
                                1:-1]
                            timer_calls[name]['MaxOverProcs'] = splits[-1][
                                1:-1]
                            timer_calls[name]['MeanOverCallCounts'] = splits[
                                -1][1:-1]
                        else:
                            name = ' '.join(splits[0:-8])
                            name = name.replace('"', '\\"')
                            timer_names.append(name)
                            timer_times[name] = {}
                            timer_times[name]['MinOverProcs'] = splits[-8]
                            timer_times[name]['MeanOverProcs'] = splits[-6]
                            timer_times[name]['MaxOverProcs'] = splits[-4]
                            timer_times[name]['MeanOverCallCounts'] = splits[
                                -2]
                            timer_calls[name] = {}
                            timer_calls[name]['MinOverProcs'] = splits[-7][
                                1:-1]
                            timer_calls[name]['MeanOverProcs'] = splits[-5][
                                1:-1]
                            timer_calls[name]['MaxOverProcs'] = splits[-3][
                                1:-1]
                            timer_calls[name]['MeanOverCallCounts'] = splits[
                                -1][1:-1]
            except RuntimeError as e:
                raise RuntimeError("Caught an error while parsing on line " +
                                   str(lineno) + ": " + e.args[0])

        if timer_serial == None:
            # We did not encounter any timers
            yaml_string += '}}'

        try:
            yaml_data = yaml.load(yaml_string)
        except yaml.parser.ParserError:
            raise RuntimeError(
                'Could not parse YAML out. Did you select the right mode?')

        return yaml_data
Ejemplo n.º 6
0
import cv
import numpy as np
from PyQt4 import QtGui
from PyQt4 import QtCore
import ipdb
import traceback
import ArenaController
from FishTrackerWidget import FishTrackerWidget
from utility_widgets import PathSelectorWidget
from utility_widgets import LabeledSpinBox
from transitions import Machine

# Set up state machine logging to std out
import logging
from transitions import logger
logger.setLevel(logging.INFO)
ch = logging.StreamHandler(sys.stdout)
ch.setLevel(logging.INFO)
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
ch.setFormatter(formatter)
logger.addHandler(ch)

from itertools import tee, izip
def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = tee(iterable)
    next(b, None)
    return izip(a, b)

class Side:
    S1 = 1
Ejemplo n.º 7
0
import logging
from transitions import logger, Machine, State

logger.setLevel(logging.INFO)

states = ['liquid', 'solid', 'gas', 'plasma']

transitions = [{
    'trigger': 'melt',
    'source': 'solid',
    'dest': 'liquid'
}, {
    'trigger': 'evaporate',
    'source': 'liquid',
    'dest': 'gas'
}, {
    'trigger': 'ionize',
    'source': 'gas',
    'dest': 'plasma'
}]

# Business as usual
machine = Machine(states=states, transitions=transitions, initial='solid')
Ejemplo n.º 8
0
def log2yaml(filename, presvec):
    # construct the YAML string
    # 2nd version, using FSM (Finite State Machine)
    states = ['none', 'transient', 'nonlinear', 'linear', 'l_setup', 'l_solutiontime', 'l_iteration']
    transitions = [
        { 'trigger': 'n2t',              'source': 'none',                        'dest': 'transient'  },
        { 'trigger': 't2n',              'source': 'transient',                   'dest': 'none'       },
        { 'trigger': 't2nl',             'source': 'transient',                   'dest': 'nonlinear'  },
        { 'trigger': 'nl2t',             'source': 'nonlinear',                   'dest': 'transient'  },
        { 'trigger': 'nl2l',             'source': 'nonlinear',                   'dest': 'linear'     },
        { 'trigger': 'l2l_setup',        'source': 'linear',                      'dest': 'l_setup'    },
        { 'trigger': 'l_setup2l',        'source': 'l_setup',                     'dest': 'linear'     },
        { 'trigger': 'l2l_solutiontime', 'source': 'linear',                      'dest': 'l_solutiontime'    },
        { 'trigger': 'l_solutiontime2l_iteration', 'source': 'l_solutiontime',    'dest': 'l_iteration'},        
        { 'trigger': 'l_iteration2t',    'source': 'l_iteration',                 'dest': 'transient'  },
        { 'trigger': 'n2nl',             'source': 'none',                        'dest': 'nonlinear'  },
        { 'trigger': 'n2l_setup',        'source': 'none',                        'dest': 'l_setup'  }
    ]

    logger.setLevel(logging.INFO)

    machine = Drekar()
    M = Machine(model=machine, states=states, transitions=transitions, initial='none')

    mode = 'drekar'
    start_stepper                   = 'Entering Rythmos::.*::advanceStepperToTime'
    end_stepper                     = 'Leaving Rythmos::.*::advanceStepperToTime'
    start_c_step                    = 'Entering Rythmos::.*::takeStep'
    end_c_step                      = 'Leaving Rythmos::.*::takeStep'
    start_nl_step                   = '(?<=Nonlinear Solver Step )\d*'
    end_nl_step_good                = '\(Converged!\)'
    end_nl_step_bad                 = '\(Failed!\)'
    start_l_step                    = 'CALCULATING FORCING TERM'
    start_residual_aztecoo          = 'Problem: Thyra::DefaultBlockedLinearOp'
    start_setuptime                 = '(?<=TimeMonitor results over )\d*'
    end_setuptime                   = '(?<=MueLu setup time )\d*'
    end_simulation                  = '(?<=Drekar run completed.)'
    start_solutiontime              = '(?<=Solution time: ).*(?= \(sec.\))'
    end_l_step                      = '(?<=total iterations: )\d*'
    close_file                      = 'CLOSEFILE'
    
    #end_residual_belos_good         = '(?<=returned a solve status of "SOLVE_STATUS_CONVERGED" in )\d*'
    #end_residual_belos_bad          = '(?<=returned a solve status of "SOLVE_STATUS_UNCONVERGED" in )\d*'
    
    #mid_timers                      = '.* \(.*\)\s*$'
    #end_timers                      = '==========='

    timer_names  = []
    timer_times  = {}
    timer_calls  = {}
    timer_serial = None

    nl_step = 0
    t_step  = 0
    lineno  = 0
    
    l_setuptimes = []

    cur_setup_time = 0.0

    yaml_string = '{"scheme":"' + mode + '","Steps":{'
    with open(filename) as f:
        try:
            for line in f:
                lineno += 1
                if   re.search(start_stepper, line) != None:
                    if machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    t_step  = 0
                    
                elif re.search(end_stepper, line) != None:
                    if machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)

                elif re.search(start_c_step, line) != None:
                    if machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    machine.n2t()

                    if yaml_string[-1] != '{':
                        yaml_string += ','
                    yaml_string += '"c_step_' + str(t_step) + '":{'

                elif re.search(end_c_step, line) != None:
                    if machine.state != 'transient':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    machine.t2n()

                    yaml_string += ', "nl_its":' + str(nl_step-1) + '}'

                    nl_step  = 0
                    t_step  += 1
                
                # start NONLINEAR state
                elif re.search(start_nl_step, line) != None:
		    print 'start nonlinear state...'
                    if machine.state != 'transient' and machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    
                    if machine.state == 'none':
		      machine.n2nl()
                    elif machine.state == 'transient':
		      machine.t2nl()
		    

                    if yaml_string[-1] != '{':
                        yaml_string += ','
                    yaml_string += '"nl_step_' + str(nl_step) + '":{'

                    nl_step += 1
                    
                elif re.search(end_nl_step_good, line) != None or re.search(end_nl_step_bad, line) != None:
		    print 'end nonlinear state...'
                    if machine.state != 'nonlinear':
                        raise RuntimeError('Wrong state: ' + machine.state)
                    machine.nl2t()

		    print yaml_string

                    # Get rid of ",nl_step_?:{}
                    i = 1
                    while (yaml_string[-i] != ','):
                         i += 1
                    yaml_string = yaml_string[:-i]
              
                    print yaml_string
                # start LINEAR state
                elif re.search(start_l_step, line) != None:
		    print 'start linear state...'
                    if machine.state != 'nonlinear':
                        raise RuntimeError('Wrong state: ' + machine.state)
		    machine.nl2l()

		    l_setuptimes[:] = [] # empty list of setup times
		    	    
                # Collect setup time data for MueLu             
                elif re.search(start_setuptime, line) != None:
		    print 'collect setup time...'
		    if machine.state == 'none' or machine.state == 'transient':
			continue
                    if machine.state != 'linear' and machine.state != 'none':
                        raise RuntimeError('Wrong state: ' + machine.state)
		      
		    machine.l2l_setup()

		elif re.search(end_setuptime, line) != None:
		    print 'collect setup time done...'
                    if machine.state != 'l_setup':
                        raise RuntimeError('Wrong state: ' + machine.state)
		                   
                    m = re.search(end_setuptime, line)
                    if m != None:
                        tt = m.group()
                    else:
                        m = re.search(end_timers_aztecoo, line)
                        tt = m.group()
                    cur_setup_time = line.split(" ")[6]
                    
                    l_setuptimes.append(float(cur_setup_time))
                    
                    machine.l_setup2l()

		# extract linear solution time
                elif re.search(start_solutiontime, line) != None:
		    print 'extract solution time...'
                    if machine.state != 'linear':
                        raise RuntimeError('Wrong state: ' + machine.state)

		    machine.l2l_solutiontime()
		    
                    m = re.search(start_solutiontime, line)
                    tt = m.group()
                    yaml_string += '  "solve_time":' + str(tt)   
                   
                    machine.l_solutiontime2l_iteration()

		# extract linear iterations
		# end LINEAR state
                elif re.search(end_l_step, line) != None:
		    print 'extract iterations...'
                    if machine.state != 'l_iteration':
                        raise RuntimeError('Wrong state: ' + machine.state)

                    m = re.search(end_l_step, line)
                    tt = m.group()
                    yaml_string += ', "its":' + str(tt)   
                   
		    yaml_string += ', "setup_time":' + str(sum(l_setuptimes)) + '}'
		    l_setuptimes[:] = []
                   
                    machine.l_iteration2t()                             
                    print 'end linear state...'
                elif re.search(end_simulation, line) != None:
		  
		    print 'end simulation'
		    
                elif re.search(close_file, line) != None:
		    if machine.state == 'linear':
			yaml_string += ' "its": -1' + ' }'
                        machine.l2t()
                       
		    if machine.state == 'nonlinear':
                        machine.nl2t()

			# Get rid of ",nl_step_?:{}
			i = 1
			while (yaml_string[-i] != ','):
			    i += 1
			yaml_string = yaml_string[:-i]
                    
                    if machine.state == 'transient':
		      	i = 1
			while (yaml_string[-i] != ','):
			    i += 1
			yaml_string = yaml_string[:-i]
			yaml_string += ', "nl_its":' + str(nl_step) + '}'
			nl_step  = 0
			machine.t2n()

		  
        except RuntimeError as e:
            raise RuntimeError("Caught an error while parsing on line " + str(lineno) + ": " + e.args[0])

    if timer_serial == None:
        # We did not encounter any timers
        yaml_string += '}}'

    print yaml_string
    print yaml.load(yaml_string)

    try:
        yaml_data = yaml.load(yaml_string)
    except yaml.parser.ParserError:
        raise RuntimeError('Could not parse YAML out. Did you select the right mode?')

    
    return yaml_data
Ejemplo n.º 9
0
def log2yaml_fsm(filename):
    # construct the YAML string
    # 2nd version, using FSM (Finite State Machine)
    states = ['none', 'transient', 'nonlinear', 'linear', 'timers']
    transitions = [
        { 'trigger': 'n2m',     'source': 'none',       'dest': 'timers'     },
        { 'trigger': 'n2t',     'source': 'none',       'dest': 'transient'  },
        { 'trigger': 't2n',     'source': 'transient',  'dest': 'none'       },
        { 'trigger': 't2nl',    'source': 'transient',  'dest': 'nonlinear'  },
        { 'trigger': 'nl2t',    'source': 'nonlinear',  'dest': 'transient'  },
        { 'trigger': 'nl2l',    'source': 'nonlinear',  'dest': 'linear'     },
        { 'trigger': 'l2nl',    'source': 'linear',     'dest': 'nonlinear'  },
        { 'trigger': 'l2t',     'source': 'linear',     'dest': 'transient'  },
        { 'trigger': 'm2n',     'source': 'timers',     'dest': 'none'       }
    ]

    logger.setLevel(logging.INFO)

    machine = Drekar()
    M = Machine(model=machine, states=states, transitions=transitions, initial='none')

    mode = 'drekar'
    start_stepper                   = 'Entering Rythmos::.*::advanceStepperToTime'
    end_stepper                     = 'Leaving Rythmos::.*::advanceStepperToTime'
    start_c_step                    = 'Entering Rythmos::.*::takeStep'
    end_c_step                      = 'Leaving Rythmos::.*::takeStep'
    start_nl_step                   = '(?<=Nonlinear Solver Step )\d*'
    end_nl_step                     = '\(Converged!\)'
    start_residual_belos            = '\*\*\*\*\* Belos Iterative Solver: '
    mid_residual                    = 'Iter.*, \[.*\] :\s*.*'
    end_residual_belos              = '(?<=returned a solve status of "SOLVE_STATUS_CONVERGED" in )\d*'
    start_timers                    = '(?<=TimeMonitor results over )\d*'
    mid_timers                      = '.* \(.*\)\s*$'
    end_timers                      = '==========='

    timer_names  = []
    timer_times  = {}
    timer_calls  = {}
    timer_serial = None

    nl_step = 0
    t_step  = 0

    yaml_string = '{"scheme":"' + mode + '","Steps":{'
    with open(filename) as f:
        for line in f:
            if   re.search(start_stepper, line) != None:
                if machine.state != 'none':
                    raise RuntimeError('Wrong state: ' + machine.state)
                t_step  = 0

            elif re.search(end_stepper, line) != None:
                if machine.state != 'none':
                    raise RuntimeError('Wrong state: ' + machine.state)

            elif re.search(start_c_step, line) != None:
                if machine.state != 'none':
                    raise RuntimeError('Wrong state: ' + machine.state)
                machine.n2t()

                if yaml_string[-1] != '{':
                    yaml_string += ','
                yaml_string += '"c_step_' + str(t_step) + '":{'

            elif re.search(end_c_step, line) != None:
                if machine.state != 'transient':
                    raise RuntimeError('Wrong state: ' + machine.state)
                machine.t2n()

                yaml_string += ', "nl_its":' + str(nl_step) + '}'

                nl_step  = 0
                t_step  += 1

            elif re.search(start_nl_step, line) != None:
                if machine.state != 'transient':
                    raise RuntimeError('Wrong state: ' + machine.state)
                machine.t2nl()

                if yaml_string[-1] != '{':
                    yaml_string += ','
                yaml_string += '"nl_step_' + str(nl_step) + '":{'

                nl_step += 1

            elif re.search(end_nl_step, line) != None:
                if machine.state != 'nonlinear':
                    raise RuntimeError('Wrong state: ' + machine.state)
                machine.nl2t()

                # Get rid of ",nl_step_?:{}
                i = 1
                while (yaml_string[-i] != ','):
                     i += 1
                yaml_string = yaml_string[:-i]

            elif re.search(start_residual_belos, line) != None:
                if machine.state != 'nonlinear':
                    raise RuntimeError('Wrong state: ' + machine.state)
                machine.nl2l()

                if yaml_string[-1] != '{':
                    yaml_string += ','
                yaml_string += '"res_hist":['

            elif re.search(end_residual_belos, line) != None:
                if machine.state != 'linear':
                    raise RuntimeError('Wrong state: ' + machine.state)

                if   mode == 'drekar':
                    machine.l2t()
                elif mode == 'albany':
                    machine.l2nl()

                m = re.search(end_residual_belos, line)
                its = m.group()
                yaml_string += '], "its":' + its

                m = re.search('(?<=with total CPU time of ).*(?=\ sec)', line)
                belos_time = m.group()
                yaml_string += ', "solve_time":' + belos_time + '}'


            elif re.search(mid_residual, line) != None:
                if machine.state != 'linear':
                    raise RuntimeError('Wrong state: ' + machine.state)

                m = re.search('[^\s]*$', line)
                res = m.group()
                if yaml_string[-1] != '[':
                    yaml_string += ','
                yaml_string += res

            elif re.search(start_timers, line) != None:
                if machine.state != 'none':
                    raise RuntimeError('Wrong state: ' + machine.state)
                machine.n2m()

                m = re.search(start_timers, line)
                nprocs = m.group()

                if nprocs == "1":
                    timer_serial = True
                else:
                    timer_serial = False

                # Finalize stepping
                yaml_string += '}'

                yaml_string += ',"Number of processes":' + nprocs
                yaml_string += ',"Time unit":s'
                yaml_string += ',"Statistics collected":["MinOverProcs","MeanOverProcs","MaxOverProcs","MeanOverCallCounts"]'


            elif re.search(end_timers, line) != None:
                if machine.state != 'timers':
                    # there could be other ======== lines
                    continue
                machine.m2n()

                # Timer names
                yaml_string += ',"Timer names":['
                for name in timer_names:
                    if yaml_string[-1] != '[':
                        yaml_string += ','
                    yaml_string += '"' + name + '"'
                yaml_string += ']'

                # Total times
                yaml_string += ',"Total times":{'
                for name in timer_names:
                    if yaml_string[-1] != '{':
                        yaml_string += ','
                    yaml_string += '"' + name + '":{'
                    yaml_string += '"MinOverProcs":'        + timer_times[name]['MinOverProcs']
                    yaml_string += ',"MeanOverProcs":'      + timer_times[name]['MeanOverProcs']
                    yaml_string += ',"MaxOverProcs":'       + timer_times[name]['MaxOverProcs']
                    yaml_string += ',"MeanOverCallCounts":' + timer_times[name]['MeanOverCallCounts']
                    yaml_string += '}'
                yaml_string += '}'

                # Call counts
                yaml_string += ',"Call counts":{'
                for name in timer_calls:
                    if yaml_string[-1] != '{':
                        yaml_string += ','
                    yaml_string += '"' + name + '":{'
                    yaml_string += '"MinOverProcs":'        + timer_times[name]['MinOverProcs']
                    yaml_string += ',"MeanOverProcs":'      + timer_times[name]['MeanOverProcs']
                    yaml_string += ',"MaxOverProcs":'       + timer_times[name]['MaxOverProcs']
                    yaml_string += ',"MeanOverCallCounts":' + timer_times[name]['MeanOverCallCounts']
                    yaml_string += '}'
                yaml_string += '}'

                yaml_string += '}'

            elif re.search(mid_timers, line) != None:
                if machine.state != 'timers':
                    # there could be other matching lines
                    continue

                if re.search('Timer Name', line) != None:
                    # Skip header (in serial it matches the pattern)
                    continue

                splits = line.split()
                if timer_serial == True:
                    name = ' '.join(splits[0:-2])
                    name = name.replace('"', '\\"')
                    timer_names.append(name)
                    timer_times[name] = {}
                    timer_times[name]['MinOverProcs']       = splits[-2];
                    timer_times[name]['MeanOverProcs']      = splits[-2];
                    timer_times[name]['MaxOverProcs']       = splits[-2];
                    timer_times[name]['MeanOverCallCounts'] = splits[-2];
                    timer_calls[name] = {}
                    timer_calls[name]['MinOverProcs']       = splits[-1][1:-1];
                    timer_calls[name]['MeanOverProcs']      = splits[-1][1:-1];
                    timer_calls[name]['MaxOverProcs']       = splits[-1][1:-1];
                    timer_calls[name]['MeanOverCallCounts'] = splits[-1][1:-1];
                else:
                    name = ' '.join(splits[0:-8])
                    name = name.replace('"', '\\"')
                    timer_names.append(name)
                    timer_times[name] = {}
                    timer_times[name]['MinOverProcs']       = splits[-8];
                    timer_times[name]['MeanOverProcs']      = splits[-6];
                    timer_times[name]['MaxOverProcs']       = splits[-4];
                    timer_times[name]['MeanOverCallCounts'] = splits[-2];
                    timer_calls[name] = {}
                    timer_calls[name]['MinOverProcs']       = splits[-7][1:-1];
                    timer_calls[name]['MeanOverProcs']      = splits[-5][1:-1];
                    timer_calls[name]['MaxOverProcs']       = splits[-3][1:-1];
                    timer_calls[name]['MeanOverCallCounts'] = splits[-1][1:-1];

    if timer_serial == None:
        # We did not encounter any timers
        yaml_string += '}}'

    try:
        yaml_data = yaml.load(yaml_string)
    except yaml.parser.ParserError:
        raise RuntimeError('Could not parse YAML out. Did you select the right mode?')

    return yaml_data