def substitute_reorder(self, order_ops): """ Changes the reordering engine based on the log marker class. :param order_ops: The reordering marker class. :type order_ops: subclass of :class:`memoryoperations.ReorderBase` :return: None """ self._context.test_on_barrier = True if isinstance(order_ops, memoryoperations.Freorder): self._context.reorder_engine = \ reorderengines.FullReorderEngine() elif isinstance(order_ops, memoryoperations.Preorder): # TODO add macro in valgrind or # parameter inside the tool to support parameters? self._context.reorder_engine = \ reorderengines.RandomPartialReorderEngine(3) elif isinstance(order_ops, memoryoperations.Areorder): self._context.reorder_engine = \ reorderengines.AccumulativeReorderEngine() elif isinstance(order_ops, memoryoperations.Fault_only): self._context.reorder_engine = reorderengines.NoReorderEngine() elif isinstance(order_ops, memoryoperations.No_reorder_fault): self._context.reorder_engine = reorderengines.NoReorderEngine() self._context.test_on_barrier = False else: raise NotSupportedOperationException( "Not supported reorder engine: {}".format(order_ops))
def check_pair_consistency(stack, marker): """ Checks if markers do not cross. You can pop from stack only if end marker match previous one. Example OK: MACRO1.BEGIN MACRO2.BEGIN MACRO2.END MACRO1.END Example NOT OK: MACRO1.BEGIN MACRO2.BEGIN MACRO1.END MACRO2.END """ top = stack[-1][0] if top.endswith(OperationFactory.__suffix[0]): top = top[:-len(OperationFactory.__suffix[0])] if marker.endswith(OperationFactory.__suffix[-1]): marker = marker[:-len(OperationFactory.__suffix[-1])] if top != marker: raise NotSupportedOperationException( "Cannot cross markers: {0}, {1}".format(top, marker))
def get_engine(engine): if engine in engines: reorder_engine = engines[engine]() else: raise NotSupportedOperationException( "Not supported reorder engine: {}".format(engine)) return reorder_engine
def check_marker_format(marker): """ Checks if marker has proper suffix. """ for s in OperationFactory.__suffix: if marker.endswith(s): return raise NotSupportedOperationException( "Incorrect marker format {}, suffix is missing.".format( marker))
def substitute_reorder(self, order_ops): """ Changes the reordering engine based on the log marker class. :param order_ops: The reordering marker class. :type order_ops: subclass of :class:`memoryoperations.ReorderBase` :return: None """ if isinstance(order_ops, memops.ReorderFull): self._context.reorder_engine = reorderengines.FullReorderEngine() self._context.test_on_barrier = ( self._context.reorder_engine.test_on_barrier ) elif isinstance(order_ops, memops.ReorderPartial): # TODO add macro in valgrind or # parameter inside the tool to support parameters? self._context.reorder_engine = ( reorderengines.RandomPartialReorderEngine(3) ) self._context.test_on_barrier = ( self._context.reorder_engine.test_on_barrier ) elif isinstance(order_ops, memops.ReorderAccumulative): self._context.reorder_engine = ( reorderengines.AccumulativeReorderEngine() ) self._context.test_on_barrier = ( self._context.reorder_engine.test_on_barrier ) elif isinstance(order_ops, memops.ReorderReverseAccumulative): self._context.reorder_engine = ( reorderengines.AccumulativeReverseReorderEngine() ) self._context.test_on_barrier = ( self._context.reorder_engine.test_on_barrier ) elif isinstance(order_ops, memops.NoReorderDoCheck): self._context.reorder_engine = reorderengines.NoReorderEngine() self._context.test_on_barrier = ( self._context.reorder_engine.test_on_barrier ) elif isinstance(order_ops, memops.NoReorderNoCheck): self._context.reorder_engine = reorderengines.NoCheckerEngine() self._context.test_on_barrier = ( self._context.reorder_engine.test_on_barrier ) elif isinstance(order_ops, memops.ReorderDefault): self._context.reorder_engine = self._context.default_engine self._context.test_on_barrier = self._context.default_barrier else: raise NotSupportedOperationException( "Not supported reorder engine: {}".format(order_ops) )
def create_operation(string_operation, markers, stack): def check_marker_format(marker): """ Checks if marker has proper suffix. """ for s in OperationFactory.__suffix: if marker.endswith(s): return raise NotSupportedOperationException( "Incorrect marker format {}, suffix is missing.".format( marker)) def check_pair_consistency(stack, marker): """ Checks if markers do not cross. You can pop from stack only if end marker match previous one. Example OK: MACRO1.BEGIN MACRO2.BEGIN MACRO2.END MACRO1.END Example NOT OK: MACRO1.BEGIN MACRO2.BEGIN MACRO1.END MACRO2.END """ top = stack[-1][0] if top.endswith(OperationFactory.__suffix[0]): top = top[:-len(OperationFactory.__suffix[0])] if marker.endswith(OperationFactory.__suffix[-1]): marker = marker[:-len(OperationFactory.__suffix[-1])] if top != marker: raise NotSupportedOperationException( "Cannot cross markers: {0}, {1}".format(top, marker)) """ Creates the object based on the pre-formatted string. The string needs to be in the specific format. Each specific value in the string has to be separated with a `;`. The first field has to be the name of the operation, the rest are operation specific values. :param string_operation: The string describing the operation. :param markers: The dict describing the pair marker-engine. :param stack: The stack describing the order of engine changes. :return: The specific object instantiated based on the string. """ id_ = string_operation.split(";")[0] id_case_sensitive = id_.lower().capitalize() # checks if id_ is one of memoryoperation classes mem_ops = getattr(memoryoperations, id_case_sensitive, None) # if class is not one of memoryoperations # it means it can be user defined marker if mem_ops is None: check_marker_format(id_) # if id_ is section BEGIN if id_.endswith(OperationFactory.__suffix[0]): # BEGIN defined by user marker_name = id_.partition('.')[0] if markers is not None and marker_name in markers: engine = markers[marker_name] try: mem_ops = getattr(memoryoperations, engine) except AttributeError: raise NotSupportedOperationException( "Not supported reorder engine: {}".format(engine)) # BEGIN but not defined by user else: mem_ops = stack[-1][1] if issubclass(mem_ops, memoryoperations.ReorderBase): stack.append((id_, mem_ops)) # END section elif id_.endswith(OperationFactory.__suffix[-1]): check_pair_consistency(stack, id_) stack.pop() mem_ops = stack[-1][1] # here we have proper memory operation to perform, # it can be Store, Fence, ReorderDefault etc. id_ = mem_ops.__name__ if id_ not in OperationFactory.__factories: OperationFactory.__factories[id_] = mem_ops.Factory() return OperationFactory.__factories[id_].create(string_operation)