Giovanni LB
706 baris
24 KiB
Python
Executable File
706 baris
24 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import sys
|
|
if sys.version_info[0] < 3:
|
|
raise Exception("Must be using Python 3")
|
|
|
|
import os
|
|
import sys
|
|
import time
|
|
import socket
|
|
from pathlib import Path
|
|
from struct import *
|
|
from collections import defaultdict
|
|
import json
|
|
import time
|
|
import http.server
|
|
import socketserver
|
|
import socket
|
|
import asyncio
|
|
import websockets
|
|
from multiprocessing import Process, Manager
|
|
import numpy as np
|
|
from copy import deepcopy
|
|
from http import HTTPStatus
|
|
from io import BytesIO
|
|
|
|
class Readable:
|
|
def __init__(self, jsonstring):
|
|
self.jsonstr = json.dumps(jsonstring)
|
|
self.seek = 0
|
|
|
|
def read(self, length=0):
|
|
if length<=0:
|
|
return self.jsonstr
|
|
else:
|
|
if self.seek >= len(self):
|
|
self.seek = 0
|
|
return None
|
|
response = self.jsonstr[self.seek:self.seek+length]
|
|
self.seek += length
|
|
return bytes(response, 'utf-8')
|
|
|
|
def __len__(self):
|
|
return len(self.jsonstr)
|
|
|
|
MAX_STITCHED_TOKENS = 3000000
|
|
MAX_FAILED_STITCHES = 256
|
|
STACK_SIZE_LIMIT = 64
|
|
|
|
SMEM = 1
|
|
SALU = 2
|
|
VMEM = 3
|
|
FLAT = 4
|
|
LDS = 5
|
|
VALU = 6
|
|
JUMP = 7
|
|
NEXT = 8
|
|
IMMED = 9
|
|
BRANCH = 10
|
|
GETPC = 11
|
|
SETPC = 12
|
|
SWAPPC = 13
|
|
LANEIO = 14
|
|
DONT_KNOW = 100
|
|
|
|
WaveInstCategory = {
|
|
SMEM: "SMEM",
|
|
SALU: "SALU",
|
|
VMEM: "VMEM",
|
|
FLAT: "FLAT",
|
|
LDS: "LDS",
|
|
VALU: "VALU",
|
|
JUMP: "JUMP",
|
|
NEXT: "NEXT",
|
|
IMMED: "IMMED",
|
|
JUMP: "JUMP",
|
|
NEXT: "NEXT",
|
|
IMMED: "IMMED",
|
|
BRANCH: "BRANCH",
|
|
GETPC: "GETPC",
|
|
SETPC: "SETPC",
|
|
SWAPPC: "SWAPPC",
|
|
LANEIO: "LANEIO",
|
|
DONT_KNOW: "DONT_KNOW",
|
|
}
|
|
|
|
JSON_GLOBAL_DICTIONARY = {}
|
|
|
|
class RegisterWatchList:
|
|
def __init__(self, labels):
|
|
self.registers = {'v'+str(k): [[] for m in range(64)] for k in range(64)}
|
|
for k in range(64):
|
|
self.registers['s'+str(k)] = []
|
|
self.labels = labels
|
|
|
|
def try_translate(self, tok):
|
|
if tok[0] in ['s']:
|
|
return self.registers[self.range(tok)[0]]
|
|
elif '@' in tok:
|
|
return self.labels[tok.split('@')[0]]+1
|
|
|
|
def range(self, r):
|
|
reg = r.split(':')
|
|
if len(reg) == 1:
|
|
return reg
|
|
else:
|
|
r0 = reg[0].split('[')
|
|
return [r0[0]+str(k) for k in range(int(r0[1]), int(reg[1][:-1])+1)]
|
|
|
|
def tokenize(self, line):
|
|
return [u for u in [t.split(',')[0].strip() for t in line.split(' ')] if len(u) > 0]
|
|
|
|
def getpc(self, line, next_line):
|
|
#print('Get pc:', line)
|
|
dst = line.split(' ')[1].strip()
|
|
label_dest = next_line.split(', ')[-1].split('@')[0]
|
|
for reg in self.range(dst):
|
|
#print('Setting:', reg, label_dest, self.labels[label_dest])
|
|
self.registers[reg].append(deepcopy(self.labels[label_dest]))
|
|
|
|
def swappc(self, line, line_num):
|
|
tokens = self.tokenize(line)
|
|
dst = tokens[1]
|
|
src = tokens[2]
|
|
popped = self.registers[self.range(src)[0]][-1]
|
|
self.registers[self.range(src)[0]] = self.registers[self.range(src)[0]][:-1]
|
|
self.registers[self.range(dst)[0]].append(line_num+1)
|
|
return popped
|
|
|
|
def setpc(self, line):
|
|
#print('Set pc:', line)
|
|
src = line.split(' ')[1].strip()
|
|
#print('Going to:', self.registers[self.range(src)[0]], src)
|
|
popped = self.registers[self.range(src)[0]][-1]
|
|
self.registers[self.range(src)[0]] = self.registers[self.range(src)[0]][:-1]
|
|
return popped
|
|
|
|
def updatelane(self, line):
|
|
tokens = self.tokenize(line)
|
|
try:
|
|
#print('Lane:', tokens)
|
|
if 'v_readlane' in tokens[0]:
|
|
self.registers[tokens[1]].append(self.registers[tokens[2]][int(tokens[3])][-1])
|
|
#print('Writelane value', self.registers[tokens[2]][int(tokens[3])])
|
|
self.registers[tokens[2]][int(tokens[3])] = self.registers[tokens[2]][int(tokens[3])][:-1]
|
|
elif 'v_writelane' in tokens[0]:
|
|
self.registers[tokens[1]][int(tokens[3])].append(self.registers[tokens[2]][-1])
|
|
self.registers[tokens[2]] = self.registers[tokens[2]][-STACK_SIZE_LIMIT:]
|
|
#print('Readlane value', self.registers[tokens[2]])
|
|
except Exception as e:
|
|
#print(e, 'Could not set:', line)
|
|
pass
|
|
|
|
|
|
def try_match_swapped(insts, code, i, line):
|
|
return insts[i+1][1] == code[line][1] and insts[i][1] == code[line+1][1]
|
|
|
|
def Match(inst_value, code_value):
|
|
if code_value == inst_value:
|
|
return True
|
|
if code_value in [GETPC, SWAPPC, SETPC] and inst_value==SALU:
|
|
return True
|
|
if code_value == BRANCH and inst_value in [JUMP, NEXT]: # TODO: Maybe lets not reorder branches?
|
|
return True
|
|
return False
|
|
|
|
def get_match_lookahead(insts, code, i, line):
|
|
if try_match_swapped(insts, code, i, line):
|
|
return [i+1, i]
|
|
new_inst_order = []
|
|
|
|
allowed_insts = list(range(i, min(i+4, len(insts))))
|
|
for l in range(line, min(line+10, len(code))):
|
|
bMatch = False
|
|
for j in allowed_insts:
|
|
if Match(insts[j][1], code[l][1]):
|
|
new_inst_order.append(j)
|
|
allowed_insts.remove(j)
|
|
bMatch = True
|
|
break
|
|
if bMatch == False:
|
|
break
|
|
if len(new_inst_order):
|
|
new_inst_order += [j for j in list(range(i, max(new_inst_order)+1)) if j not in new_inst_order]
|
|
return new_inst_order
|
|
|
|
def stitch(insts, raw_code, jumps):
|
|
result, i, line, loopCount, N = [], 0, 0, defaultdict(int), len(insts)
|
|
|
|
SMEM_INST = []
|
|
VMEM_INST = []
|
|
FLAT_INST = []
|
|
NUM_SMEM = 0
|
|
NUM_VMEM = 0
|
|
NUM_FLAT = 0
|
|
|
|
mem_unroll = []
|
|
flight_count = []
|
|
|
|
labels = {}
|
|
jump_map = [0]
|
|
code = [raw_code[0]]
|
|
for c in raw_code[1:]:
|
|
c = list(c)
|
|
c[0] = c[0].split(';')[0].split('//')[0].strip()
|
|
|
|
if c[1] != 100:
|
|
code.append(c)
|
|
elif ':' in c[0]:
|
|
labels[c[0].split(':')[0]] = len(code)
|
|
jump_map.append(len(code)-1)
|
|
|
|
reverse_map = []
|
|
for k, v in enumerate(jump_map):
|
|
if v >= len(reverse_map):
|
|
reverse_map.append(k)
|
|
|
|
jumps = {jump_map[j]+1: j for j in jumps}
|
|
|
|
smem_ordering = 0
|
|
vmem_ordering = 0
|
|
max_line = 0
|
|
|
|
watchlist = RegisterWatchList(labels=labels)
|
|
|
|
num_failed_stitches = 0
|
|
loops = 0
|
|
maxline = 0
|
|
|
|
while i < N:
|
|
#print('L', line)
|
|
loops += 1
|
|
if line >= len(code) or loops > MAX_STITCHED_TOKENS or num_failed_stitches > MAX_FAILED_STITCHES:
|
|
break
|
|
|
|
maxline = max(reverse_map[line], maxline)
|
|
inst = insts[i]
|
|
|
|
as_line = code[line]
|
|
max_line = max(max_line, reverse_map[line])
|
|
|
|
matched = True
|
|
next = line+1
|
|
if as_line[1] == GETPC: # TODO: @ can put you ahead of label!
|
|
watchlist.getpc(as_line[0], code[line+1][0])
|
|
matched = inst[1] == SALU
|
|
elif as_line[1] == LANEIO:
|
|
watchlist.updatelane(as_line[0])
|
|
matched = inst[1] == VALU
|
|
elif as_line[1] == SETPC:
|
|
next = watchlist.setpc(as_line[0])
|
|
matched = inst[1] == SALU
|
|
elif as_line[1] == SWAPPC:
|
|
next = watchlist.swappc(as_line[0], line)
|
|
#print('Next:', next, code[next])
|
|
matched = inst[1] == SALU
|
|
elif inst[1] == as_line[1]:
|
|
if line in jumps:
|
|
loopCount[jumps[line]-1] += 1 # label is the previous line
|
|
num_inflight = NUM_FLAT + NUM_SMEM + NUM_VMEM
|
|
|
|
if inst[1] == SMEM or inst[1] == LDS:
|
|
smem_ordering = 1 if inst[1] == SMEM else smem_ordering
|
|
SMEM_INST.append([reverse_map[line], num_inflight])
|
|
NUM_SMEM += 1
|
|
elif inst[1] == VMEM or (inst[1] == FLAT and 'global_' in as_line[0]):
|
|
VMEM_INST.append([reverse_map[line], num_inflight])
|
|
NUM_VMEM += 1
|
|
if 'buffer_' in as_line[0]:
|
|
#watchlist.LDS_buffer_op(as_line[0])
|
|
vmem_ordering = 1
|
|
elif inst[1] == FLAT:
|
|
smem_ordering = 1
|
|
vmem_ordering = 1
|
|
FLAT_INST.append([reverse_map[line], num_inflight])
|
|
NUM_FLAT += 1
|
|
elif inst[1] == IMMED and 'waitcnt' in as_line[0]:
|
|
|
|
if 'lgkmcnt' in as_line[0]:
|
|
wait_N = int(as_line[0].split('lgkmcnt(')[1].split(')')[0])
|
|
flight_count.append([as_line[-1], num_inflight, wait_N])
|
|
if wait_N == 0:
|
|
smem_ordering = 0
|
|
if smem_ordering == 0:
|
|
offset = len(SMEM_INST)-wait_N
|
|
mem_unroll.append( [reverse_map[line], SMEM_INST[:offset]+FLAT_INST] )
|
|
SMEM_INST = SMEM_INST[offset:]
|
|
NUM_SMEM = len(SMEM_INST)
|
|
FLAT_INST = []
|
|
NUM_FLAT = 0
|
|
else:
|
|
NUM_SMEM = min(max(wait_N-NUM_FLAT, 0), NUM_SMEM)
|
|
NUM_FLAT = min(max(wait_N-NUM_SMEM, 0), NUM_FLAT)
|
|
num_inflight = NUM_FLAT + NUM_SMEM + NUM_VMEM
|
|
|
|
if 'vmcnt' in as_line[0]:
|
|
wait_N = int(as_line[0].split('vmcnt(')[1].split(')')[0])
|
|
flight_count.append([as_line[-1], num_inflight, wait_N])
|
|
if wait_N == 0:
|
|
vmem_ordering = 0
|
|
if vmem_ordering == 0:
|
|
offset = len(VMEM_INST)-wait_N
|
|
mem_unroll.append( [reverse_map[line], VMEM_INST[:offset]+FLAT_INST] )
|
|
VMEM_INST = VMEM_INST[offset:]
|
|
NUM_VMEM = len(VMEM_INST)
|
|
FLAT_INST = []
|
|
NUM_FLAT = 0
|
|
else:
|
|
NUM_VMEM = min(max(wait_N-NUM_FLAT, 0), NUM_VMEM)
|
|
NUM_FLAT = min(max(wait_N-NUM_VMEM, 0), NUM_FLAT)
|
|
|
|
elif inst[1] == JUMP and as_line[1] == BRANCH:
|
|
next = jump_map[as_line[2]]
|
|
if next is None or next == 0:
|
|
print('Jump to unknown location!', as_line)
|
|
break
|
|
elif inst[1] == NEXT and as_line[1] == BRANCH:
|
|
next = line + 1
|
|
else:
|
|
matched = False
|
|
next = line + 1
|
|
if i+1 < N and line+1 < len(code):
|
|
if try_match_swapped(insts, code, i, line):
|
|
temp = insts[i]
|
|
insts[i] = insts[i+1]
|
|
insts[i+1] = temp
|
|
next = line
|
|
elif 's_waitcnt' in as_line[0] or '_load_' in as_line[0]:
|
|
print(as_line)
|
|
break
|
|
|
|
if matched:
|
|
new_res = inst + (reverse_map[line],) # (line,)
|
|
result.append(new_res)
|
|
i += 1
|
|
num_failed_stitches = 0
|
|
else:
|
|
num_failed_stitches += 1
|
|
line = next
|
|
|
|
N = max(N, 1)
|
|
if len(result) != N:
|
|
print('Warning - Stitching rate: '+str(len(result) * 100 / N)+'% matched')
|
|
print('Leftovers:', [WaveInstCategory[insts[i+k][1]] for k in range(5) if i+k < len(insts)])
|
|
try:
|
|
print(line, code[line])
|
|
except:
|
|
pass
|
|
else:
|
|
while line < len(code):
|
|
if 's_endpgm' in code[line]:
|
|
mem_unroll.append( [reverse_map[line], SMEM_INST+VMEM_INST+FLAT_INST] )
|
|
break
|
|
line += 1
|
|
|
|
return result, loopCount, mem_unroll, flight_count, maxline
|
|
|
|
|
|
def get_ip():
|
|
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
|
|
s.settimeout(0)
|
|
try:
|
|
hostname = socket.gethostname()
|
|
IPAddr = socket.gethostbyname(hostname)
|
|
s.connect(({IPAddr}, 1))
|
|
except Exception:
|
|
IPAddr = '127.0.0.1'
|
|
finally:
|
|
return IPAddr
|
|
|
|
|
|
IPAddr = get_ip()
|
|
PORT, WebSocketPort = 8000, 18000
|
|
SP = '\u00A0'
|
|
|
|
def extract_tuple(content, num):
|
|
vals = content.split(',')
|
|
assert (len(vals) == num)
|
|
last_val = vals[-1][:-1] if vals[-1].endswith(')') else vals[-1]
|
|
vals = [vals[0][1:]] + vals[1:-1] + [last_val]
|
|
return tuple(int(val) for val in vals)
|
|
|
|
|
|
def get_top_n(stitched):
|
|
TOP_N = 10
|
|
by_line_num = defaultdict(lambda: [0, 0, 0])
|
|
for (_, _, s2i, run_time, line_num) in stitched:
|
|
entry = by_line_num[line_num]
|
|
entry[0] += 1
|
|
entry[1] += s2i
|
|
entry[2] += run_time
|
|
top_n = sorted(
|
|
[(line_num, v[0], v[1], v[2])
|
|
for (line_num, v) in by_line_num.items()],
|
|
key=lambda x: x[2] + x[3],
|
|
reverse=True)
|
|
return top_n[:TOP_N]
|
|
|
|
|
|
def wave_info(df, id):
|
|
dic = {
|
|
'Issue': df['issued_ins'][id],
|
|
'Valu': df['valu_ins'][id], 'Valu_stall': df['valu_stalls'][id],
|
|
'Salu': df['salu_ins'][id], 'Salu_stall': df['salu_stalls'][id],
|
|
'Vmem': df['vmem_ins'][id], 'Vmem_stall': df['vmem_stalls'][id],
|
|
'Smem': df['smem_ins'][id], 'Smem_stall': df['smem_stalls'][id],
|
|
'Flat': df['flat_ins'][id], 'Flat_stall': df['flat_stalls'][id],
|
|
'Lds': df['lds_ins'][id], 'Lds_stall': df['lds_stalls'][id],
|
|
'Br': df['br_ins'][id], 'Br_stall': df['br_stalls'][id],
|
|
}
|
|
dic['Issue_stall'] = int(np.sum([dic[key] for key in dic.keys() if '_STALL' in key]))
|
|
return dic
|
|
|
|
|
|
def extract_waves(waves):
|
|
result, slot2seq = [], {}
|
|
for id in waves['id']:
|
|
row = {key: waves[key][id] for key in waves.keys()}
|
|
|
|
insts, timeline = [], []
|
|
for x in row['instructions'].split('),'):
|
|
if len(x) > 0:
|
|
insts.append(extract_tuple(x, 4))
|
|
for x in row['timeline'].split('),'):
|
|
if len(x) > 0:
|
|
timeline.append(extract_tuple(x, 2))
|
|
|
|
# aggregate per wave slot
|
|
if (row['simd'], row['wave_slot']) in slot2seq:
|
|
slot = result[slot2seq[(row['simd'], row['wave_slot'])]]
|
|
last_end_time = slot[2][-1][-1]
|
|
slot[2] += (row['id'], row['begin_time'], row['end_time']),
|
|
slot[3] += insts
|
|
# filler between waves
|
|
slot[4] += (0, row['begin_time'] - last_end_time),
|
|
slot[4] += timeline
|
|
else:
|
|
slot2seq[row['simd'], row['wave_slot']] = len(result)
|
|
result.append([row['simd'], row['wave_slot'],
|
|
[(row['id'], row['begin_time'], row['end_time'])],
|
|
insts,
|
|
timeline])
|
|
|
|
return result
|
|
|
|
|
|
def extract_data(df, se_number, code, jumps):
|
|
if len(df['id']) == 0 or len(df['instructions']) == 0 or len(df['timeline']) == 0:
|
|
return None
|
|
|
|
cu_waves = extract_waves(df)
|
|
all_filenames = []
|
|
flight_count = []
|
|
maxgrade = [{df['wave_slot'][wave_id]: -1 for wave_id in df['id']} for k in range(4)]
|
|
non_stitched = [{df['wave_slot'][wave_id]: -1 for wave_id in df['id']} for k in range(4)]
|
|
|
|
print('Number of waves:', len(df['id']))
|
|
|
|
for wave_id in df['id']:
|
|
if non_stitched[df['simd'][wave_id]][df['wave_slot'][wave_id]] == 0:
|
|
continue
|
|
insts, timeline = [], []
|
|
if len(df['instructions'][wave_id]) == 0 or len(df['timeline'][wave_id]) == 0:
|
|
continue
|
|
|
|
for x in df['instructions'][wave_id].split('),'):
|
|
insts.append(extract_tuple(x, 4))
|
|
for x in df['timeline'][wave_id].split('),'):
|
|
timeline.append(extract_tuple(x, 2))
|
|
|
|
stitched, loopCount, mem_unroll, count, maxline = stitch(insts, code, jumps)
|
|
srate = len(stitched)**2 / max(len(insts), 1)
|
|
if srate <= maxgrade[df['simd'][wave_id]][df['wave_slot'][wave_id]]:
|
|
continue
|
|
|
|
maxgrade[df['simd'][wave_id]][df['wave_slot'][wave_id]] = srate
|
|
non_stitched[df['simd'][wave_id]][df['wave_slot'][wave_id]] = len(insts) - len(stitched)
|
|
flight_count.append(count)
|
|
|
|
wave_entry = {
|
|
"id": int(df['id'][wave_id]),
|
|
"simd": int(df['simd'][wave_id]),
|
|
"slot": int(df['wave_slot'][wave_id]),
|
|
"begin": int(df['begin_time'][wave_id]),
|
|
"end": int(df['end_time'][wave_id]),
|
|
"info": wave_info(df, wave_id),
|
|
"instructions": stitched,
|
|
"timeline": timeline,
|
|
"code": code[:maxline+16],
|
|
"waitcnt": mem_unroll
|
|
}
|
|
data_obj = {
|
|
"name": 'SE'.format(se_number),
|
|
"kernel": code[0][0],
|
|
"duration": sum(dur for (_, dur) in timeline),
|
|
"wave": wave_entry,
|
|
"simd_waves": [],
|
|
"cu_waves": cu_waves,
|
|
"loop_count": loopCount,
|
|
"top_n": get_top_n(stitched),
|
|
"websocket_port": WebSocketPort,
|
|
"generation_time": time.ctime()
|
|
}
|
|
if len(data_obj["cu_waves"]) == 0:
|
|
continue
|
|
|
|
OUT = 'se'+str(se_number)+'_sm'+str(df['simd'][wave_id])+'_wv'+str(df['wave_slot'][wave_id])+'.json'
|
|
JSON_GLOBAL_DICTIONARY[OUT] = Readable(data_obj)
|
|
all_filenames.append(OUT)
|
|
|
|
return flight_count, all_filenames
|
|
|
|
|
|
class NoCacheHTTPRequestHandler(http.server.SimpleHTTPRequestHandler):
|
|
def end_headers(self):
|
|
self.send_my_headers()
|
|
http.server.SimpleHTTPRequestHandler.end_headers(self)
|
|
|
|
def send_my_headers(self):
|
|
self.send_header("Cache-Control", "no-cache, no-store, must-revalidate")
|
|
self.send_header("Pragma", "no-cache")
|
|
self.send_header("Expires", "0")
|
|
|
|
def do_GET(self):
|
|
global PICTURE_CALLBACK
|
|
if 'timeline.png?' in self.path:
|
|
selections = [int(s)!=0 for s in self.path.split('timeline.png?')[1]]
|
|
counters_json, imagebytes, _, _ = PICTURE_CALLBACK(selections[1:], selections[0])
|
|
JSON_GLOBAL_DICTIONARY['counters.json'] = counters_json
|
|
JSON_GLOBAL_DICTIONARY[self.path.split('/')[-1]] = imagebytes
|
|
|
|
if '.json' in self.path or 'timeline.png' in self.path or 'wstates' in self.path:
|
|
try:
|
|
response_file = JSON_GLOBAL_DICTIONARY[self.path.split('/')[-1]]
|
|
#print(response_file)
|
|
except:
|
|
print('Invalid json request:', self.path)
|
|
self.send_error(HTTPStatus.NOT_FOUND, "File not found")
|
|
print(JSON_GLOBAL_DICTIONARY.keys())
|
|
return
|
|
self.send_response(HTTPStatus.OK)
|
|
self.send_header("Content-Length", str(len(response_file)))
|
|
if '.b' in self.path:
|
|
self.send_header("Content-type", 'application/octet-stream')
|
|
response_file = BytesIO(response_file)
|
|
elif 'timeline.png' in self.path:
|
|
self.send_header("Content-type", 'image/png')
|
|
else:
|
|
self.send_header("Content-type", 'application/json')
|
|
self.send_header("Last-Modified", self.date_time_string(time.time()))
|
|
self.end_headers()
|
|
self.copyfile(response_file, self.wfile)
|
|
elif self.path in ['/', '/styles.css', '/index.html', '/logo.svg']:
|
|
http.server.SimpleHTTPRequestHandler.do_GET(self)
|
|
else:
|
|
print('Invalid request:', self.path)
|
|
self.send_error(HTTPStatus.NOT_FOUND, "File not found")
|
|
|
|
|
|
class RocTCPServer(socketserver.TCPServer):
|
|
def server_bind(self):
|
|
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
|
|
self.socket.bind(self.server_address)
|
|
|
|
|
|
def run_server():
|
|
Handler = NoCacheHTTPRequestHandler
|
|
os.chdir(os.path.join(os.path.dirname(os.path.abspath(__file__)),'ui'))
|
|
try:
|
|
with RocTCPServer((IPAddr, PORT), Handler) as httpd:
|
|
httpd.serve_forever()
|
|
except KeyboardInterrupt:
|
|
pass
|
|
|
|
|
|
def fix_space(line):
|
|
line = line.replace(' ', SP)
|
|
line = line.replace('\t', SP*4)
|
|
return line
|
|
|
|
|
|
def WebSocketserver(websocket, path):
|
|
data = websocket.recv()
|
|
print(354, data)
|
|
cpp, ln, _ = data.split(':')
|
|
ln = int(ln)
|
|
HL, EMP = 'highlight', ''
|
|
content = None
|
|
print("loading...")
|
|
try:
|
|
f = open(cpp, 'r', errors='replace')
|
|
content = ''.join('<li class=\"line_'+str(i)+
|
|
str(HL if i==ln else EMP)+'">'+str(i).ljust(5)+fix_space(l)+'</li>'
|
|
for i, l in enumerate(f.readlines(), 1))
|
|
except FileNotFoundError:
|
|
content = cpp + ' not found!'
|
|
websocket.send(content)
|
|
|
|
|
|
def run_websocket():
|
|
start_server = websockets.serve(WebSocketserver, IPAddr, WebSocketPort)
|
|
try:
|
|
asyncio.get_event_loop().run_until_complete(start_server)
|
|
asyncio.get_event_loop().run_forever()
|
|
except KeyboardInterrupt:
|
|
pass
|
|
|
|
|
|
def assign_ports(ports):
|
|
ps = [int(port) for port in ports.split(',')]
|
|
if ps[0] <= 5000 or ps[1] <= 5000:
|
|
print('Need to have port values > 5000')
|
|
sys.exit(1)
|
|
elif ps[0] == ps[1]:
|
|
print('Can not use the same port for both web server and websocket server: '+ps[0])
|
|
sys.exit(1)
|
|
global IPAddr, PORT, WebSocketPort
|
|
PORT, WebSocketPort = ps[0], ps[1]
|
|
|
|
|
|
def call_picture_callback(return_dict):
|
|
global PICTURE_CALLBACK
|
|
response, imagebytes, wstates, counter_events = PICTURE_CALLBACK()
|
|
return_dict['counters.json'] = response
|
|
return_dict['timeline.png'] = imagebytes
|
|
for n, m in enumerate(wstates):
|
|
return_dict['wstates'+str(n)+'.json'] = Readable({"data": [int(n) for n in list(np.asarray(m))]})
|
|
for n, e in enumerate(counter_events):
|
|
return_dict['se'+str(n)+'_perfcounter.json'] = Readable({"data": [v.toTuple() for v in e]})
|
|
|
|
def view_trace(args, code, jumps, dbnames, att_filenames, bReturnLoc, pic_callback, OCCUPANCY, bDumpOnly):
|
|
global PICTURE_CALLBACK
|
|
PICTURE_CALLBACK = pic_callback
|
|
manager = Manager()
|
|
return_dict = manager.dict()
|
|
JSON_GLOBAL_DICTIONARY['occupancy.json'] = Readable({str(k): OCCUPANCY[k] for k in range(len(OCCUPANCY))})
|
|
|
|
pic_thread = Process(target=call_picture_callback, args=(return_dict,))
|
|
pic_thread.start()
|
|
|
|
assert(len(dbnames) > 0)
|
|
att_filenames = [Path(f).name for f in att_filenames]
|
|
se_numbers = [int(a.split('_se')[1].split('.att')[0]) for a in att_filenames]
|
|
flight_count = []
|
|
simd_wave_filenames = {}
|
|
|
|
for se_number, dbname in zip(se_numbers, dbnames):
|
|
if len(dbname['id']) == 0:
|
|
continue
|
|
|
|
count, wv_filenames = extract_data(dbname, se_number, code, jumps)
|
|
|
|
if count is not None:
|
|
flight_count.append(count)
|
|
simd_wave_filenames[se_number] = wv_filenames
|
|
|
|
if bReturnLoc:
|
|
return flight_count
|
|
|
|
for key in simd_wave_filenames.keys():
|
|
wv_array = [[
|
|
int(s.split('_sm')[1].split('_wv')[0]),
|
|
int(s.split('_wv')[1][0]),
|
|
s
|
|
] for s in simd_wave_filenames[key]]
|
|
|
|
wv_dict = {}
|
|
for wv in wv_array:
|
|
try:
|
|
wv_dict[wv[0]][wv[1]] = wv[2]
|
|
except:
|
|
try:
|
|
wv_dict[wv[0]] = {wv[1]: wv[2]}
|
|
except:
|
|
exit(-1)
|
|
|
|
simd_wave_filenames[key] = wv_dict
|
|
|
|
JSON_GLOBAL_DICTIONARY['filenames.json'] = Readable({"filenames": simd_wave_filenames})
|
|
|
|
if pic_thread is not None:
|
|
pic_thread.join()
|
|
for k, v in return_dict.items():
|
|
JSON_GLOBAL_DICTIONARY[k] = v
|
|
|
|
if bDumpOnly == False:
|
|
if args.ports:
|
|
assign_ports(args.ports)
|
|
print('serving at ports: {0},{1}'.format(PORT, WebSocketPort))
|
|
try:
|
|
PROCS = [Process(target=run_server), Process(target=run_websocket)]
|
|
for p in PROCS:
|
|
p.start()
|
|
for p in PROCS:
|
|
p.join()
|
|
except KeyboardInterrupt:
|
|
print("Exitting.")
|
|
else:
|
|
os.makedirs('ui', exist_ok=True)
|
|
for k, v in JSON_GLOBAL_DICTIONARY.items():
|
|
if '.json' in k:
|
|
try:
|
|
with open(os.path.join('ui',k), 'w') as f:
|
|
f.write(v.read())
|
|
except:
|
|
pass
|