Test your AI Agents with the all-new Agent to Agent Testing Platform.Learn More
How to use iTerminate method in fMBT
Best Python code snippet using fMBT_python
decisionTree.py
Source:decisionTree.py 
1from __future__ import division2from pacman import Directions3from game import Agent4import api5import random6import game7import util8import sys9import os10import csv11import math12import numpy as np13from uuid import uuid414import copy15# My classifier is a decision tree with post-pruning to reducing over-fitting.16# The decision tree is built recursively, selecting the attribute that minimises average gini score.17# The data is split 80/20, with 80% used to build the tree, and the remaining data is held back to implement post-pruning.18# Post-pruning is implemented by iteratively pruning nodes at the bottom of the tree whenever pruning improves accuracy on the 20%.19# No external machine learning libraries (e.g. SKLearn) have been used.20# My code includes tree learning, tree pruning, prediction and train/test splitting21def getMinValueOfDictionary(d):22 # Utility function: given a dictionary it will return a list of the keys associated with the min value.23 minValue = min(d.values())24 keys = [k for k, v in d.items() if v == minValue]25 return keys26def modalValue(array):27 # Utility function: returns the most common item in a list28 return max(set(array), key=list(array).count)29def gini(c):30 # The gini measure for identifying the best attribute to split on31 # The function takes a 1D numpy array and returns a float which is the gini measure for that array32 # Count the frequency of each class and store a total so we can calculate the probabilities33 y_counts = np.unique(c, return_counts=True)[1]34 size = np.sum(y_counts)35 # Calculate the probabilities, and store a list of the sum of the squares of them36 probabilities = [value / size for value in y_counts]37 H = [p ** 2 for p in probabilities]38 # Return 1 - sum(probabilities)39 return 1 - np.sum(H)40def splitBranch(combineddata, attribute):41 # Takes a combined numpy array and returns two, split on the passed attribute (always assumed to only contain 0s or 1s).42 # First we filter the data, splitting on whether the attribute is 0 or 143 split1 = combineddata[combineddata[:, attribute] == 0]44 split2 = combineddata[combineddata[:, attribute] == 1]45 # Then we remove the attribute we used as we don't use it again46 split1 = np.delete(split1, attribute, axis=1)47 split2 = np.delete(split2, attribute, axis=1)48 # Return a tuple with the two new datasets49 return (split1, split2)50def expectedGini(combineddata, attribute):51 # This function calculates the expected gini index across the two resultant datasets for a branch.52 # It assumes both the data and the target are labelled 0/1.53 # It will not work for non-binary attributes54 class1, class2 = splitBranch(combineddata, attribute)55 class1_size = len(class1) / (len(class1) + len(class2))56 class2_size = len(class2) / (len(class1) + len(class2))57 return class1_size * gini(class1[:, -1]) + class2_size * gini(class2[:, -1])58def bestAttribute(dataset):59 # This method takes a 2D numpy array and returns the attribute on which a binary split will result in the lowest average gini index60 columns = range(len(dataset[0])) # Simply creates a list of attribute IDs of the required length61 # Create a dictionary, keyed by the attributes, with the entropy/gini for each62 expectedGinis = {columns[t]: expectedGini(dataset, t) for t in range(len(columns) - 1)}63 # There may be more than one 'best attribute' where they have the same expected gini value, in which case we select one of the highest at random64 bestattribute = random.choice(getMinValueOfDictionary(expectedGinis))65 return bestattribute66def shouldTerminate(dataset):67 # This method supports the control of the iteration that builds the decision tree. It makes this decision based on the dataset passed to it.68 # We terminate if either all the samples have the same class (case 1) OR if we have run out of examples (case 2) OR we have run out of attributes (case 3)69 # Split the combined dataset in to the X's and the labels70 classes = dataset[:, -1]71 attributes = dataset[:, 0:-1]72 # Case 173 doITerminate = all(classes[0] == thisClass for thisClass in classes)74 if doITerminate: return True75 # Case 276 if len(attributes) == 0:77 return True78 # Case 379 else:80 doITerminate = all(all(attributes[0] == att) for att in attributes)81 return doITerminate82def plurality(classes):83 # This method takes a list of classes, and returns the most common one. It is used for classification at leaf nodes.84 return max(set(classes), key=list(classes).count)85def classification(dataset, parentdataset):86 # If the classes for the data at the leaf node are all the same, then we return that class87 if len(np.unique(dataset[:, -1])) == 1:88 return dataset[0, -1]89 # If we have more than one class in the dataset, we take the most common result in the dataset (plurality)90 elif len(np.unique(dataset[:, -1])) > 1:91 return plurality(dataset[:, -1])92 # If we have nothing in the dataset (no examples), then we take plurality from the parent93 else:94 return plurality(parentdataset[:, -1])95class Node:96 # The objects in my tree are nodes which can be either 'branchingNode' or 'leafNode.' This class is a parent class for both which contains pruning logic.97 # Nodes are referenced in the tree by a uuid which is generated by the uuid library on demand.98 def pruneTreeAt(self, uuid):99 # This method will return a new tree, but pruned at the node supplied. If passed a node ID that doesn't exist, it will simply return the existing tree.100 if self.id == uuid:101 return LeafNode(self.dataset, id=self.id)102 elif self.isLeaf:103 return self104 else:105 return BranchingNode(self.attributeToSplitOn, self.leftTree.pruneTreeAt(uuid),106 self.rightTree.pruneTreeAt(uuid), dataset=self.dataset, id=self.id)107class BranchingNode(Node):108 # Branching nodes are those in the tree that are not leaves (i.e. have children).109 def __init__(self, attributeToSplitOn, leftTree, rightTree, dataset=None, isRoot=False, id=None):110 self.isRoot = isRoot # This is true only for the first node created111 self.isLeaf = False112 self.id = str(uuid4()) if id is None else id # We give uuids to every node, so we can reference them later during pruning. If a node id is passed in to the constructor, e.g. after pruning it will preserve the old ID.113 self.dataset = dataset # Store the dataset used to branch on this node. It only gets used in the case of pruning, when the branching node gets converted in to a leaf node.114 # Record which attribute was selected at this point and allocate the two subtrees115 self.attributeToSplitOn = attributeToSplitOn # Store the attribute that was used to branch on this node116 # Store the child nodes of this node117 self.leftTree = leftTree118 self.rightTree = rightTree119 def predict(self, x):120 # Once the tree exists, predict will recursively call itself, traversing the tree until it finds a leaf node, which will return a prediction121 # It takes parameter 'x' which is a feature vector of data122 value = x[self.attributeToSplitOn] # Get the value of the feature vector at the relevant attribute123 x = np.delete(x, self.attributeToSplitOn) # Because we delete attributes as we built the tree, we must also delete them from the feature vector to ensure alignment124 # The branching statement below traverses left or right down the tree depending on 'value'125 if value == 0:126 return self.leftTree.predict(x)127 elif value == 1:128 return self.rightTree.predict(x)129 def isPrunable(self):130 # Prunable nodes are those with two leaf children. This method is used by getPrunableNodes()131 return self.leftTree.isLeaf and self.rightTree.isLeaf132class LeafNode(Node):133 # Leaf nodes are those nodes at the bottom of the tree with no children.134 def __init__(self, dataset, parentDataset=None, id=None):135 self.isLeaf = True136 self.id = str(uuid4()) if id is None else id # Similar to branching nodes, we assign uuids to each node.137 # We store the predicted class associated with the classification method. We must pass both the dataset, and the parent's dataset. The latter is only used if the former is empty.138 self.predictedClass = classification(dataset, parentDataset)139 # Predict will be called by the branching node above the leaf node. We can simply return the value we stored in the attribute when creating the tree.140 def predict(self, x):141 # This method returns the predicted class that the constructor stored in the leaf node142 return self.predictedClass143 def isPrunable(self):144 # Leaf nodes are never prunable145 return False146# The decision tree is build recursively. The method checks for the terminating conditions, and otherwise recursively calls itself to split the data using the best attribute.147def generateTree(dataset, parentDataset=None, isRoot=False):148 # First we check for termination conditions149 if (shouldTerminate(dataset)):150 return LeafNode(dataset, parentDataset=parentDataset)151 # Otherwise we choose the attribute to split on, split the dataset and recursively call the function on the two childen.152 else:153 attributeToSplitOn = bestAttribute(dataset)154 splitDataset = splitBranch(dataset, attributeToSplitOn)155 # As well as the two new datasets, we pass the current dataset incase they need to classify using plurality on their parent156 return BranchingNode(attributeToSplitOn, generateTree(splitDataset[0], dataset),157 generateTree(splitDataset[1], dataset), dataset=dataset, isRoot=isRoot)158class Tree:159 # This class is a wrapper for the node objects, with some additional methods that get called on the entire tree160 # We use this method if we are rebuilding an existing tree (e.g. after pruning)161 def fromNode(self, node):162 self.tree = node163 # We use this method to preprocess the data and then generate the tree.164 def fit(self, data, target):165 # Convert the data to numpy arrays if it isn't already166 data = np.array(data)167 self.target = np.array(target)168 # This will drop any columns for which all values are the same. These don't contain any information.169 # This means the classifier can be safely extended to e.g. random forests where we don't select from all attributes at every node.170 # If we had multiple completely sparse attributes, then random forests fails when all the attributes it considers at a node are sparse.171 self.data = data[:, np.invert(np.all(data == data[0, :], axis=0))]172 self.droppedAttributes = np.arange(data.shape[1])[np.all(data == data[0, :], axis=0)]173 # We combine the two arrays in to one big one, call the generateTree method and store the result174 combineddata = np.concatenate((self.data, self.target[:, None]), axis=1)175 self.tree = generateTree(combineddata, isRoot=True)176 def predict(self, x):177 # This method passes through to the top node of the tree178 return self.tree.predict(x)179 def test(self, X_test, y_test):180 # This method returns the accuracy of the tree on a new dataset. This is required for pruning.181 predictions = [self.predict(x) for x in X_test] # Create predictions for all values in the dataset182 predictions_vs_actuals = np.unique((y_test - predictions) == 0, return_counts=True) # Count the number of correct predictions and store in a dictionary183 predictions_dict = dict(zip(predictions_vs_actuals[0], predictions_vs_actuals[1]))184 total = np.sum(predictions_vs_actuals)185 # Next line manages an edge case where no predictions were correct. Without this the following calculation would have a key error.186 if True not in predictions_dict.keys(): predictions_dict[True] = 0187 # Return the accuracy score188 accuracy = predictions_dict[True] / total189 return accuracy190def getPrunableNodes(node):191 # This function is used for pruning. Given a tree node, it returns all the nodes that could be pruned below it.192 prunableNodes = [] # Create an empty list to store the results of the inner function193 # This inner function is used because we search the tree recursively. If we returned within the outer function, it would stop searching too early.194 def getPrunableNodes_inner(node):195 if node.isPrunable():196 prunableNodes.append(node.id)197 if not node.isLeaf:198 getPrunableNodes_inner(node.leftTree)199 getPrunableNodes_inner(node.rightTree)200 getPrunableNodes_inner(node)201 return prunableNodes202def pruneTree(tree, X_test, y_test):203 # This function implements post-pruning on a tree to reduce overfitting. It takes a tree, and some new data which we held back.204 # It starts at the bottom of the tree, checking 'prunable' nodes. It will compare accuracy before and after pruning a node, and if pruning increases accuracy it will retain it.205 # The function returns a newly pruned tree.206 # We create an initial baseline for accuracy207 treeAccuracy = tree.test(X_test, y_test)208 # This control variable manages the while loop209 continueIterating = True210 while continueIterating:211 continueIterating = False212 # Fetch all prunable nodes on the current tree213 prunableNodes = getPrunableNodes(tree.tree)214 # Iterate through the prunable nodes215 for prunableNode in prunableNodes:216 # Create a new tree with the node pruned217 prunedTree = Tree()218 prunedTree.fromNode(tree.tree.pruneTreeAt(prunableNode))219 prunedTreeAccuracy = prunedTree.test(X_test, y_test)220 # Compare accuracy to the baseline. If 'as good' or better, then we adopt the new tree221 if prunedTreeAccuracy >= treeAccuracy:222 tree = copy.deepcopy(prunedTree)223 continueIterating = True # Because we changed the tree, there may be new prunable nodes to check.224 return tree225def train_test_split(data, target, test_proportion):226 # This function splits the data in to two, according to the proportions passed in the parameter227 # If necessary, convert the data to numpy objects228 data = np.array(data)229 target = np.array(target)230 # We create a list of random integers which will be the integers of the rows we select in to each group.231 shuffledInts = np.random.permutation(len(data))232 # We chop the list of shuffled integers in the proportions passed in the parameter233 testIndices = shuffledInts[:int(test_proportion * len(data))]234 trainIndices = shuffledInts[int(test_proportion * len(data)):]235 # We return four numpy arrays as a tuple236 return (data[trainIndices], data[testIndices], target[trainIndices], target[testIndices])237# An agent that runs a classifier to decide what to do.238class ClassifierAgent(Agent):239 # Constructor. This gets run when the agent starts up.240 def __init__(self):241 print "Initialising"242 # Take a string of digits and convert to an array of243 # numbers. Exploits the fact that we know the digits are in the244 # range 0-4.245 #246 # There are undoubtedly more elegant and general ways to do this,247 # exploiting ASCII codes. This function and the code that reads the file in to data and target is not mine. Line 383 onwards is.248 def convertToArray(self, numberString):249 numberArray = []250 for i in range(len(numberString) - 1):251 if numberString[i] == '0':252 numberArray.append(0)253 elif numberString[i] == '1':254 numberArray.append(1)255 elif numberString[i] == '2':256 numberArray.append(2)257 elif numberString[i] == '3':258 numberArray.append(3)259 elif numberString[i] == '4':260 numberArray.append(4)261 return numberArray262 263 # This gets run on startup. Has access to state information.264 #265 # Here we use it to load the training data.266 def registerInitialState(self, state):267 # open datafile, extract content into an array, and close.268 self.datafile = open('good-moves.txt', 'r')269 content = self.datafile.readlines()270 self.datafile.close()271 # Now extract data, which is in the form of strings, into an272 # array of numbers, and separate into matched data and target273 # variables.274 self.data = []275 self.target = []276 # Turn content into nested lists277 for i in range(len(content)):278 lineAsArray = self.convertToArray(content[i])279 dataline = []280 for j in range(len(lineAsArray) - 1):281 dataline.append(lineAsArray[j])282 self.data.append(dataline)283 targetIndex = len(lineAsArray) - 1284 self.target.append(lineAsArray[targetIndex])285 # I use my train_test_split function to split the data and target in to a training dataset, and hold back 20% which is then used for pruning286 X_train, X_test, y_train, y_test = train_test_split(self.data, self.target, 0.2)287 # I create a tree object and fit using the training data288 dtree = Tree()289 dtree.fit(X_train, y_train)290 # Prune the tree using the held back data and store the result.291 self.prunedTree = pruneTree(dtree, X_test, y_test)292 293 # Tidy up when Pacman dies (not my code)294 def final(self, state):295 print "I'm done!"296 # Turn the numbers from the feature set into actions (not my code):297 def convertNumberToMove(self, number):298 if number == 0:299 return Directions.NORTH300 elif number == 1:301 return Directions.EAST302 elif number == 2:303 return Directions.SOUTH304 elif number == 3:305 return Directions.WEST306 # Here we just run the classifier to decide what to do307 def getAction(self, state):308 # Get the current feature vector and identify the legal moves309 features = api.getFeatureVector(state)310 legal = api.legalActions(state)311 # We use the predict method of our tree to predict the best move.312 move = self.prunedTree.predict(features)313 move = self.convertNumberToMove(move)314 print move...
translate.py
Source:translate.py
1#!/usr/bin/env python32# -------------------------------------------------------------------------------3# PROJECT: FPGA Brainfuck4# -------------------------------------------------------------------------------5# AUTHORS: Pavel Benacek <pavel.benacek@gmail.com>6# LICENSE: The MIT License (MIT), please read LICENSE file7# WEBSITE: https://github.com/benycze/fpga-brainfuck/8# -------------------------------------------------------------------------------9import pdb10import readline11from lib.isa import BIsa12from lib.template import *13class BTranslationError(Exception):14 """15 Error during the translation was detected16 """17 def __init__(self,message,line,column):18 self.line = line19 self.column = column20 self.message = "Error {}:{} - {}".format(line,column,message)21 super().__init__(self.message)22class BTranslate(object):23 """24 Class for handling of translation from the Brainfuck 25 code to the BCPU code.26 """27 def __init__(self,in_file,debug,memory_map,addr_width,outfile):28 """29 Initilization of the class which takes care of the 30 translation to the BCPU.31 Parameters:32 - in_file - input file to translate (string)33 - debug - debug is enabled (bool)34 - memory_map - generate the output memory map (bool). 35 The output file will have the ${outfile}.mif36 -hex addr - required hexadecimal address width37 - Outfile - output file name (string)38 """39 self.in_file = in_file40 self.debug = debug41 self.memory_map = memory_map42 self.outfile = outfile43 self.memory_map_name = outfile + ".mif"44 self.memory_hmap_name = outfile + ".hex"45 self.memory_addr_width = addr_width46 # Helping variables - source code parsing47 self.line_buf = ''48 self.line_cnt = 049 self.char_cnt = 050 self.last_sym = ''51 # Helping variables - memroy files52 self.mem_pos = 053 def __get_char(self):54 """55 Return a char from the input. The method56 raises eof of the file if we are done.57 """58 # Read line if the buffer is empty59 if self.line_buf == '':60 self.line_cnt = self.line_cnt + 161 self.line_buf = self.inf.readline()62 self.char_cnt = 063 if len(self.line_buf) == 0:64 # Nothing else to read 65 return ''66 67 # Extract one character68 self.char_cnt = self.char_cnt + 169 char = self.line_buf[0]70 self.line_buf = self.line_buf[1:]71 return char72 def __process_comment(self):73 """74 Process comment - read the comment from the input untill the newline is detected75 """76 comment = ""77 while True:78 ## Read the input untill the new line is detected79 char = self.__get_char()80 if (char is '\n') or (char is ''):81 break82 comment = comment + char83 # End of the while84 if(self.debug):85 print("Lexer: Parsed comment => {}".format(comment))86 def __get_symbol(self):87 """88 Get the symbol from the input, skip comments89 Comments are beginning with // and are on one line90 The symbol is stored inside the variable self.last_sym91 """92 while True:93 # Chek if we are not done, skip white spaces94 char = self.__get_char()95 if char == '':96 # Nothing else to read97 self.last_sym = ''98 break99 if char.isspace():100 continue 101 # Check if we are working with the comment102 if char is "/":103 char = self.__get_char()104 if not(char is "/"):105 BTranslationError("Expecting / symbol",self.line_cnt,self.char_cnt)106 # Process the commend and run the parsing again after you are done107 self.__process_comment()108 continue109 # Check if we are working with allowed110 # symbol.111 if not(BIsa.contains(char)):112 raise BTranslationError("Uknown symbol was detected",self.line_cnt,self.char_cnt) 113 # Yahoo ... we can return the symbol which is possible to translate114 if self.debug:115 print("Lexer: Parser symbol => {}".format(char))116 # Remember the symbol and escape from the function117 self.last_sym = char118 break119 def __translate_body(self):120 """121 Translate the body of the BCPU program122 Returns: The translated code (human readable form - tuple (instruction,address)123 """124 # The body consits of non-jump instructions - if the instruction [ or ] is detected125 # the following will happen:126 # 1) The [ is translated as the pass to the __translate_cycle method127 # 2) The ] is translated as the return from the method which means that the cycle128 # is being processed inside the __translate_cycle129 #130 inst_body = [] 131 # Get the symbol and analyze iff we are working with the JUMP instruction132 while True:133 self.__get_symbol()134 # Check if we have something to process135 if self.last_sym is '':136 if self.debug:137 print("No other symbol to process, ending.")138 # No other instruction, return nop139 nop_inst = ((";",0),self.mem_pos)140 self.mem_pos = self.mem_pos + BIsa.INST_WIDTH141 inst_body.append(nop_inst)142 break143 # Check if we are working with any jump symbol, dump the body into the list144 # and escape from the cycle145 if BIsa.is_bjump(self.last_sym):146 cycle_body = self.__translate_cycle()147 inst_body.extend(cycle_body)148 continue149 if BIsa.is_ejump(self.last_sym):150 # We have a closing parenthesis inside the body, end the processing there and return151 # to the upper __translate cycle152 break153 # Check if we are working with a body instruction, we will return 154 # the error if not155 if not(BIsa.is_body_instruction(self.last_sym)):156 raise BTranslationError("Unknown symbol {}.".format(self.last_sym), self.line_cnt, self.char_cnt)157 # So far so good, add it into the list and try next symbol158 inst = ((self.last_sym,0), self.mem_pos)159 if self.debug:160 print("Dumping the instruction: {}".format(str(inst)))161 inst_body.append(inst)162 self.mem_pos = self.mem_pos + BIsa.INST_WIDTH163 # We are out ... time to dump our code164 return inst_body165 def __add_cycle_padding(self):166 """167 Add the jump padding - two no-ops168 """169 ret = []170 ret.append((("&",0), self.mem_pos))171 self.mem_pos = self.mem_pos + BIsa.INST_WIDTH172 ret.append(((";",0), self.mem_pos))173 self.mem_pos = self.mem_pos + BIsa.INST_WIDTH174 return ret175 def __translate_cycle(self):176 """177 Translate the BCPU cycle construction178 Returns: The translated code (human readable form) - tuple ((jump_instr,val),address)179 """180 inst_body = []181 # The translate cycle should detect the opening symbol [ and 182 # closing symbol ]183 # Fine ... check if we have an opening symbol184 if not(self.last_sym is '['):185 raise BTranslationError("Cycle opening [ not found, detected {}.".format(self.last_sym), self.line_cnt, self.char_cnt)186 # Remember the first address, translate the body, remember the return address and construct187 # the jump instruction.188 # Each jump needs to be predecessed by the preload operation (to store data in the execution stage) and 189 # one NOP instruction to have a fresh data in stage 2 (jump analysis)190 f_pad_jmpend = self.__add_cycle_padding()191 bAddress = self.mem_pos192 self.mem_pos = self.mem_pos + BIsa.INST_WIDTH193 body_code = self.__translate_body()194 f_pad_jmpbegin = self.__add_cycle_padding()195 eAddress = self.mem_pos196 self.mem_pos = self.mem_pos + BIsa.INST_WIDTH197 # Check if we have a closing symbol198 if not(self.last_sym is ']'):199 raise BTranslationError("Cycle closing ] not found, detected {}.".format(self.last_sym), self.line_cnt, self.char_cnt) 200 # We are done ... everything is fine. Time to dump our functionality201 # Front jump -- we need to jump to the next address behind the ]202 # Back jump -- we need to jump the address which is relatively from the ], following the ]203 fJumpOffset = eAddress - bAddress + BIsa.INST_WIDTH204 bJumpOffset = eAddress - bAddress - BIsa.INST_WIDTH205 if self.debug:206 print("bAddress = 0x{:x}".format(bAddress))207 print("eAdress = 0x{:x}".format(eAddress))208 print("fJump \"[\" value is 0x{:x}".format(fJumpOffset))209 print("bJump \"]\" value is 0x{:x}".format(bJumpOffset))210 # Check that offsets are no longer than 255 bytes211 max_jmp = 2 ** 12 - 1212 if fJumpOffset > max_jmp or bJumpOffset > max_jmp:213 raise BTranslationError("Jump is longer than {} B.".format(max_jmp), self.line_cnt, self.char_cnt)214 # Generate the [215 inst_body.extend(f_pad_jmpend)216 fJump = (("[",fJumpOffset), bAddress)217 inst_body.append(fJump)218 # Append body to the list219 inst_body.extend(body_code)220 # Generate the ] and return the body221 inst_body.extend(f_pad_jmpbegin)222 bJump = (("]",bJumpOffset), eAddress)223 inst_body.append(bJump)224 return inst_body225 def __memory_map_to_bin(self, mem_map):226 """227 Covert the memroy map to a binary form.228 Return: Byte form of the file uploaded to the BCPU229 """230 if(self.debug):231 print("Dumping the memory map to its binary form")232 ret = bytearray()233 for m_elem,_ in mem_map:234 # Check if we are working with symbol or 235 # jump instruction. Each instruction is encoded as (inst, addr),236 # where inst can be a symbol or jump tuple (jmp,val)237 bF = None238 if BIsa.is_jump_instruction(m_elem[0]):239 bF = BIsa.translate_jump(m_elem[0],m_elem[1])240 else:241 bF = BIsa.translate_inst(m_elem[0])242 243 # Append the result of the conversion244 ret.extend(bF)245 return ret246 def __dump_inst(self,m_elem):247 """248 Translate one memory element whichis a tuple of instruction249 and data (inst, data)250 Return: Translated instruction251 """252 # Prepare data - m_elem is not a tuple iff we are not working253 # with a jump instruction254 bData = 0255 sym = m_elem[0]256 if BIsa.is_jump_instruction(sym):257 # It is a jump instruction258 bData = BIsa.translate_jump(m_elem[0],m_elem[1])259 else:260 # It is an instruction261 bData = BIsa.translate_inst(sym)262 return bData263 def __dump_mem_map(self,mem_map):264 """265 Store the memory map into the file. The format of the 266 file is MIF (https://www.intel.com/content/www/us/en/programmable/quartushelp/13.0/mergedProjects/reference/glossary/def_mif.htm)267 All tempaltes are defined in the template.py file.268 """269 ret = mif_hdr_template.format(self.outfile, len(mem_map) * BIsa.INST_WIDTH, 8)270 # Length of dumped data is the number of programm instructions times the instruction271 # size272 # Dump the memory layout273 for m_elem,addr in mem_map:274 bData = self.__dump_inst(m_elem)275 # Each line starts with a comment, after that we need to dump 276 # address : data277 i_arg = BIsa.get_instruction_argument(bData) # Try to decode it back278 ret += "-- Translated instruction ==> {} (parameter = 0x{} )\n".format(m_elem[0],i_arg)279 ret += mif_line_template.format(addr,bData[0])280 ret += mif_line_template.format(addr+1,bData[1])281 # End the file 282 ret += mif_end_template283 return ret284 def __dump_mem_hmap(self,mem_map):285 """286 Store the memory map in the hexadecimal format (one line per 2 bytes).287 The total number of bytes is 2**self.memory_addr_width288 """289 # Process the memory, dump it to the file290 ret = ""291 cell_addrs = 2**self.memory_addr_width292 for m_elem,_ in mem_map:293 bData = self.__dump_inst(m_elem)294 ret += hex_line_template.format(*bData)295 cell_addrs = cell_addrs - 2296 # Fill the rest of the file with zeros297 while(cell_addrs > 0):298 ret += hex_line_template.format(0,0)299 cell_addrs = cell_addrs - 2300 return ret301 def translate(self):302 """303 Run the translation of the source code304 """305 try:306 # Open the file and process the input body307 # 308 # The program is firstly parsed and constructed to the tree 309 # where the program body is stored inside the list. After we process the whole310 # program we dump the body of the program as the as the last step of each function311 # because what we need is to resolve jump vaues (which are known after the translation.312 #313 # That is the plan - let's rock!!314 self.inf = open(self.in_file,'r')315 # Get the memory map and covert it to the binary form316 bprogram = self.__translate_body()317 # Add the program termination symbol318 iTerminate = (("x",0), self.mem_pos)319 bprogram.append(iTerminate)320 # Write the memory map if it is required321 if self.memory_map:322 print("Dumping the memory map to file {}".format(self.memory_map_name))323 mem_map_content = self.__dump_mem_map(bprogram)324 mem_map_file = open(self.memory_map_name,'w')325 mem_map_file.write(mem_map_content)326 mem_map_file.close()327 print("Dumping the memory map to file {}".format(self.memory_hmap_name))328 mem_hmap_content = self.__dump_mem_hmap(bprogram)329 mem_hmap_content_file = open(self.memory_hmap_name,'w')330 mem_hmap_content_file.write(mem_hmap_content)331 mem_hmap_content_file.close()332 # Convert the memory map (human readable to the binary form)333 bin_form = self.__memory_map_to_bin(bprogram)334 out_file = open(self.outfile,'wb')335 out_file.write(bin_form)336 out_file.close()337 if self.debug:338 print("Dumping the binary code into the file {}.".format(self.outfile))339 except IOError as e:340 print("Error during the file reading/writing operation.")341 except BTranslationError as e:342 print(str(e))343 finally:344 # Close the file345 self.inf.close()...
fmbt_i.py
Source:fmbt_i.py
...89 assert _debug(last_log_line) == '</fmbt_log>', "Log unfinished (%s)" % (last_log_line,)90 assert _debug(fmbt.isalive()) == False, "Process still alive"91 os.remove(FMBT_LOGFILE)92 return True93def iTerminate():94 os.kill(fmbt.pid, signal.SIGTERM)95 process_response_time()96 return fmbt.isalive() == False97def _validateHelp(help_lines):98 _debug(help_lines)99 assert help_lines[0].startswith('Execute actions:'), "'Execute actions' expected"100 assert help_lines[-2].startswith('Unknown command'), "'Unknown command' expected"101 assert help_lines[-1] == PROMPT, "Prompt missing"102 return True103def iHelpEmptyCommand():104 output = _run_command('')105 return _validateHelp(output)106def iHelpUnknownCommand():107 output = _run_command('?')...
Automation Testing Tutorials
Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.
LambdaTest Learning Hubs:
- JUnit Tutorial
- TestNG Tutorial
- Webdriver Tutorial
- WebDriverIO Tutorial
- Protractor Tutorial
- Selenium 4 Tutorial
- Jenkins Tutorial
- NUnit Tutorial
- Jest Tutorial
- Playwright Tutorial
- Cypress Tutorial
- PyTest Tutorial
YouTube
You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.
Run fMBT automation tests on LambdaTest cloud grid
Perform automation testing on 3000+ real desktop and mobile devices online.
Try LambdaTest Now !!
Get 100 minutes of automation test minutes FREE!!
Was this article helpful?
