def send_crash_report(message, receiver=None): global emailed if emailed: return emailed = True if receiver is None: receiver = os.environ.get('TC_MONITOR_EMAIL', None) if receiver is None: tc.warning('No receiver in $TC_MONITOR_EMAIL') return tc.warning('Emailing {}'.format(receiver)) TO = receiver SUBJECT = 'Report' TEXT = message server = smtplib.SMTP('smtp.gmail.com', 587) server.ehlo() server.starttls() server.login(gmail_sender, gmail_passwd) BODY = '\r\n'.join(['To: %s' % TO, 'From: %s' % gmail_sender, 'Subject: %s' % SUBJECT, '', TEXT]) try: server.sendmail(gmail_sender, [TO], BODY) except: print('Error sending mail') server.quit() print('Press enter or Ctrl + \ to exit.')
def layout(func): assert not pytaichi.materialized, "All layout must be specified before the first kernel launch / data access." ti.warning( f"@ti.layout will be deprecated in the future, use ti.root directly to specify data layout anytime before the data structure materializes.", PendingDeprecationWarning, stacklevel=3) pytaichi.layout_functions.append(func)
def email_call_back(_): global crashed crashed = True tc.warning('Task has crashed.') message = 'Your task [{}] at machine [{}] has crashed.'.format(task_name, socket.gethostname()) send_crash_report(message) atexit.unregister(at_exit) exit(-1)
def extract_arguments(self): sig = inspect.signature(self.func) if sig.return_annotation not in (inspect._empty, None): self.return_type = sig.return_annotation params = sig.parameters arg_names = params.keys() for i, arg_name in enumerate(arg_names): param = params[arg_name] if param.kind == inspect.Parameter.VAR_KEYWORD: raise KernelDefError( 'Taichi functions do not support variable keyword parameters (i.e., **kwargs)' ) if param.kind == inspect.Parameter.VAR_POSITIONAL: raise KernelDefError( 'Taichi functions do not support variable positional parameters (i.e., *args)' ) if param.kind == inspect.Parameter.KEYWORD_ONLY: raise KernelDefError( 'Taichi functions do not support keyword parameters') if param.kind != inspect.Parameter.POSITIONAL_OR_KEYWORD: raise KernelDefError( 'Taichi functions only support "positional or keyword" parameters' ) annotation = param.annotation if annotation is inspect.Parameter.empty: if i == 0 and self.classfunc: annotation = template() else: if id(annotation) in primitive_types.type_ids: ti.warning( 'Data type annotations are unnecessary for Taichi' ' functions, consider removing it', stacklevel=4) elif not isinstance(annotation, template): raise KernelDefError( f'Invalid type annotation (argument {i}) of Taichi function: {annotation}' ) self.arguments.append(annotation) self.argument_names.append(param.name)
def benchmark_plot(fn=None, cases=None, columns=None, archs=None, title=None, bars='sync_vs_async', bar_width=0.4, bar_distance=0, left_margin=0): import taichi as ti import yaml import matplotlib.pyplot as plt if fn is None: fn = os.path.join(ti.core.get_repo_dir(), 'benchmarks', 'output', 'benchmark.yml') with open(fn, 'r') as f: data = yaml.load(f, Loader=yaml.SafeLoader) if bars != 'sync_vs_async': # need baseline baseline_dir = os.path.join(ti.core.get_repo_dir(), 'benchmarks', 'baseline') baseline_file = f'{baseline_dir}/benchmark.yml' with open(baseline_file, 'r') as f: baseline_data = yaml.load(f, Loader=yaml.SafeLoader) if cases is None: cases = list(data.keys()) assert len(cases) >= 1 if len(cases) == 1: cases = [cases[0], cases[0]] ti.warning( 'Function benchmark_plot does not support plotting with only one case for now. Duplicating the item to move on.' ) if columns is None: columns = list(data[cases[0]].keys()) normalize_to_lowest = lambda x: True figure, subfigures = plt.subplots(len(cases), len(columns)) if title is None: title = 'Taichi Performance Benchmarks (Higher means more)' figure.suptitle(title, fontweight="bold") for col_id in range(len(columns)): subfigures[0][col_id].set_title(columns[col_id]) for case_id in range(len(cases)): case = cases[case_id] subfigures[case_id][0].annotate( case, xy=(0, 0.5), xytext=(-subfigures[case_id][0].yaxis.labelpad - 5, 0), xycoords=subfigures[case_id][0].yaxis.label, textcoords='offset points', size='large', ha='right', va='center') for col_id in range(len(columns)): col = columns[col_id] if archs is None: current_archs = data[case][col].keys() else: current_archs = archs & data[case][col].keys() if bars == 'sync_vs_async': y_left = [ data[case][col][arch]['sync'] for arch in current_archs ] label_left = 'sync' y_right = [ data[case][col][arch]['async'] for arch in current_archs ]