def __init__(self, notation, cam): """ Parses the passed notation and saves values into members. @sfunc: Represents the function that returns the next given state. @ruleset: A created ruleset that matches always @offsets: Represents the Moore neighborhood corresponding to the given CAM """ self.sfunc = None self.offsets = c.Configuration.moore(cam.master) self.ruleset = r.Ruleset(r.Ruleset.Method.ALWAYS_PASS) if re.match(CAMParser.MCELL_FORMAT, notation): x, y = notation.split('/') if all(map(self._numasc, [x, y])): self.sfunc = self._mcell(x, y) else: raise ValueError("Non-ascending values in MCELL format") elif re.match(CAMParser.RLE_FORMAT, notation): B, S = map(lambda x: x[1:], notation.split('/')) if all(map(self._numasc, [B, S])): self.sfunc = self._mcell(S, B) else: raise ValueError("Non-ascending values in RLE format") else: raise ValueError("No supported format passed to parser.") # Add configuration to given CAM config = c.Configuration(self.sfunc, plane=cam.master, offsets=self.offsets) self.ruleset.configurations.append(config)
def pre_rule(): print('single: generating rule set...') traffic_pkl = setting.SINGLE_TRAFFIC_LOGFILE rate_arr = [0.1 * i for i in range(1, 10)] for rate in rate_arr: ruleset_pkl = 'single_rule_{}.pkl'.format(rate) print(ruleset_pkl) rs = ruleset.Ruleset() rs.generate_ruleset_from_traffic(traffic_pkl, 24, rate) element.serialize(rs, ruleset_pkl) return
def test_alwaysPassRuleset(self): """ """ # No configurations tmp_r = r.Ruleset(r.Ruleset.Method.ALWAYS_PASS) tmp_p = self.plane2d.bits.copy() tmp_r.apply_to(self.plane2d) assert tmp_p == self.plane2d.bits # One configuration tmp_r.configurations.append(self.config) tmp_r.apply_to(self.plane2d) assert tmp_p != self.plane2d.bits assert self.plane2d.bits.count() == 100 * 100
def pre_classbench_rule(): print('generating classbench rule set...') rs = ruleset.Ruleset() rs.generate_ruleset_from_classbench(setting.CB_RULE, setting.CB_TRACE, minpri=8) cnt = 0 tot = len(rs.ruleset) for (priority, _) in rs.ruleset: if priority == 32: cnt += 1 print(cnt) print(tot) element.serialize(rs, setting.CB_RULE_PKL) return
def test_matchRuleset(self): """ """ # No configurations tmp_r = r.Ruleset(r.Ruleset.Method.MATCH) tmp_p = self.plane2d.bits.copy() tmp_r.apply_to(self.plane2d) assert tmp_p == self.plane2d.bits # One configuration tmp_r.configurations.append(self.config) tmp_r.apply_to(self.plane2d) assert tmp_p == self.plane2d.bits self.plane2d[[(-1, 0), (0, 1), (1, 1)]] = 1 tmp_r.apply_to(self.plane2d) assert self.plane2d.bits.count() == 4
def get_rulesets(ruledir, recurse): """ List of ruleset objects extracted from the yaml directory """ if os.path.isdir(ruledir) and recurse: yaml_files = [ y for x in os.walk(ruledir) for y in glob(os.path.join(x[0], '*.yaml')) ] elif os.path.isdir(ruledir) and not recurse: yaml_files = get_files(ruledir, 'yaml') elif os.path.isfile(ruledir): yaml_files = [ruledir] extracted_files = extract_yaml(yaml_files) rulesets = [] for extracted_yaml in extracted_files: rulesets.append(ruleset.Ruleset(extracted_yaml)) return rulesets
def test_tolerateRuleset(self): """ """ # No configurations tmp_r = r.Ruleset(r.Ruleset.Method.TOLERATE) tmp_p = self.plane2d.bits.copy() tmp_r.apply_to(self.plane2d) assert tmp_p == self.plane2d.bits # One configuration tmp_r.configurations.append(self.config) tmp_r.apply_to(self.plane2d, 0.5) assert tmp_p == self.plane2d.bits self.plane2d[(-1, 0)] = 1 tmp_r.apply_to(self.plane2d, 0.5) assert self.plane2d.bits.count() == 4
def get_rulesets(ruledir, recurse): """ List of ruleset objects extracted from the yaml directory """ if os.path.isdir(ruledir) and recurse: yaml_files = [] for root, dirs, files in os.walk(ruledir): for name in files: filename, file_extension = os.path.splitext(name) if file_extension == '.yaml': yaml_files.append(os.path.join(root, name)) if os.path.isdir(ruledir) and not recurse: yaml_files = util.get_files(ruledir, 'yaml') elif os.path.isfile(ruledir): yaml_files = [ruledir] extracted_files = util.extract_yaml(yaml_files) rulesets = [] for extracted_yaml in extracted_files: rulesets.append(ruleset.Ruleset(extracted_yaml)) return rulesets
def pre_brain(pkl_file): print('generating brain rule and trace...') print('brain: transform {} into {}'.format(pkl_file, setting.BRAIN_TRAFFIC_LOGFILE)) topo = setting.BRAIN n = network.Network(topo) n.generate_real_traffic(pkl_file) n.traffic.serialize(setting.BRAIN_TRAFFIC_LOGFILE) n.traffic.print_traffic_data(setting.BRAIN_TRAFFIC_DATA) print('flow number: {}'.format(n.traffic.flownum[-1])) print('brain: generating rule set...') traffic_pkl = setting.BRAIN_TRAFFIC_LOGFILE ruleset_pkl = setting.BRAIN_RULE_PKL rs = ruleset.Ruleset() rs.generate_ruleset_from_traffic(traffic_pkl, 24, 0.5) element.serialize(rs, ruleset_pkl) return
# ----- PGLOBALS VARIABLES ----- # debug flag # rintd, assertd (often used as function I/O checks) and other potential statements only execute if this flag is enabled # DEBUG generally causes more verbose output # DEUBG makes the program more likely to halt due to unexpected inputs/outputs/conditions # considering these factors, enabling DEBUG may cause the script to run significantly slower # if DEBUG is disabled, it may prevent timing.py timing, or it may override this and continue functioning regardless of DEBUG DEBUG = False # main pokepy client client = pokepy.V2Client() # ruleset rs = ruleset.Ruleset(0) # main list of teams used by players teams = [] # number of teams to build per instance of "teammake" run default_num_teams = 2 # name of "Pokedex" folder dex_folder = "../res/dex_entries/" # list of string pokemon types all_type_names = ['bug', 'dark', 'dragon', 'electric', 'fighting', 'fire', 'flying', 'ghost', 'grass', 'ground', 'ice', 'normal', 'poison', 'psychic', 'rock', 'steel', 'water'] # ideally write this out to a file somewhere or cache it or smt