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
]
