if s in exists_cache:

return exists_cache[s]

global topology

if topology is None:

top = os.getenv("TOPOLOGY")

topology = set()

if top:

try:

topology = {x.strip() for x in open(top).readlines()}

except OSError:

print("Cannot open topology", top, file=sys.stderr)

if s in topology:

return True

found = os.path.exists(s)

exists_cache[s] = found

def __init__(self):

minor = 0

perf = os.getenv("PERF")

if not perf:

perf = "perf"

try:

version = subprocess.Popen([perf, "--version"],

stdout=subprocess.PIPE).communicate()[0]

except OSError:

print("Cannot run", perf)

version = ""

if not isinstance(version, str):

version = version.decode('utf-8')

m = re.match(r"perf version (\d+)\.(\d+)\.", version)

version = 412 # assume that no match is new enough

if m:

major = int(m.group(1))

minor = int(m.group(2))

version = major * 100 + minor

pmu = "cpu_core" if os.path.exists("/sys/devices/cpu_core") else "cpu"

self.direct = os.getenv("DIRECT_MSR") or version < 400

self.offcore = has_format("offcore_rsp", pmu) and not self.direct

self.ldlat = has_format("ldlat", pmu) and not self.direct

self.has_name = version >= 304

def __init__(self):

self.reg = {}

def writemsr(self, msrnum, val, print_only = False):

print("msr %x = %x" % (msrnum, val, ))

if print_only:

return

msrmod.writemsr(msrnum, val)

def checked_writemsr(self, msr, val, print_only = False):

if msr in self.reg:

sys.exit("Multiple events use same register")

self.writemsr(msr, val, print_only)

("amt1", "any=1", EVENTSEL_ANY, ""),

("percore", "percore=1", 0, ""),

("perf_metrics", "", 0, ""),

("i1", "inv=1", EVENTSEL_INV, ""),

("e1", "edge=1", 0, ""),

("e0", "edge=0", 0, ""),

("tx", "in_tx=1", 0, ""),

("sup", "", 0, "k"),

("usr=yes", "", 0, "u"),

("usr=no", "", 0, "k"),

("os=yes", "", 0, "k"),

("os=no", "", 0, "u"),

("anythr=yes", "any=1", 0, ""),

("anythr=no", "any=0", 0, ""),

("pdir", "", 0, "ppp"),

("precise=yes", "", 0, "pp"),

(r"event_select=" + number, "event=%#x", 0),

(r"u" + number, "umask=%#x", 0),

(r"c(?:mask=)?" + number, "cmask=%d", 24),

(r"e(?:dge=)?" + number, "edge=%d", 18),

(r'e(\d)', 'edge='),

(r't=(\d+)', "thresh="),

(r'match=(0x[0-9a-fA-F]+)', "filter_occ="),

(r'filter1=(0x[0-9a-fA-F]+)', "config1=", 32),

(r"nc=(\d+)", "filter_nc="),

(r'filter=(0x[0-9a-fA-F]+)', "config1="),

(r'one_unit', '', ),

(r"u" + number, "umask="),

(r"opc=?" + number, "filter_opc="),

(r"tid=?" + number, "filter_tid="),

nextra = ""

while extra:

if extra[0] == ":":

extra = extra[1:]

continue

found = False

for j in qualval_map:

m = re.match(j[0], extra, re.I)

if m:

if j[2]:

val |= int(m.group(1), 0) << j[2]

newe.append(j[1] % (int(m.group(1), 0)))

extra = extra[len(m.group(0)):]

found = True

break

if found:

continue

found = False

for j in qual_map:

if extra.lower().startswith(j[0]):

val |= j[2]

newe.append(j[1])

extra = extra[len(j[0]):]

nextra += j[3]

found = True

break

if found:

continue

if not extra:

break

if extra[0] in perf_qual + "p":

nextra += extra[0]

extra = extra[1:]

continue

print("bad event qualifier", extra, file=sys.stderr)

break

n = n.replace(".", "_").replace(":", "_").replace("=", "_")

if sup:

n += "_k"

def __init__(self, name, val, desc):

self.val = val

self.name = name

self.extra = ""

self.userextra = ""

self.msr = 0

self.msrval = 0

self.desc = desc

self.precise = 0

self.collectpebs = 0

self.newextra = ""

self.overflow = None

self.errata = None

self.counter = ""

self.period = 0

self.pname = None

# XXX return with pmu to be consistent with Uncore and fix callers

def output_newstyle(self, extra="", noname=False, period=False, name="", noexplode=False):

"""Format an perf event for output and return as perf event string.

Always uses new style (cpu/.../)."""

val = self.val

if extra:

extra = self.newextra + "," + extra

else:

extra = self.newextra

if self.pname:

e = self.pname

else:

e = "event=0x%x,umask=0x%x" % (val & 0xff, (val >> 8) & 0xff)

e += extra

if version.has_name:

if name:

e += ",name=" + name

elif not noname:

e += ",name=%s" % (gen_name(self.name, "sup" in (self.extra + extra)))

if period and self.period and ",period=" not in e:

e += ",period=%d" % self.period

return e

def output(self, use_raw=False, flags="", noname=False, period=False, name="", noexplode=False):

"""Format an event for output and return as perf event string.

use_raw when true return old style perf string (rXXX).

Otherwise chose between old and new style based on the

capabilities of the installed perf executable.

flags when set add perf flags (e.g. u for user, p for pebs)."""

val = self.val

newe = []

extra = "".join(sorted(merge_extra(extra_set(self.extra), extra_set(flags))))

extra, val = convert_extra(":" + extra, val, newe)

if version.direct or use_raw:

if self.pname:

ename = self.pname

else:

ename = "r%x" % (val,)

if extra:

ename += ":" + extra

# XXX should error for extras that don't fit into raw

else:

p = self.output_newstyle(extra=",".join(newe),

noname=noname, period=period, name=name)

ename = "%s/%s/" % (self.pmu, p) + extra

return ename

def filter_qual(self):

def check_qual(q):

if q == "":

return True

if "=" in q:

q, _ = q.split("=")

if has_format_any(q, self.pmu):

return True

warn_once("%s: format %s not supported. Filtering out" % (self. pmu, q))

return False

"cbo": "cbox",

"qpi_ll": "qpi",

"sbo": "sbox",

if name in row:

if row[name] == 'False':

return 0

if row[name] == 'True':

return 1

return int(row[name])

"imph-u": "arb",

"kti ll": "upi",

"m3kti": "m3upi",

"upi ll": "upi",

o = ""

while flags:

for j in uncore_map + extra_map:

if flags[0] == ",":

flags = flags[1:]

match, repl = j[0], j[1]

m = re.match(match, flags, re.I)

if m:

if repl == "":

pass

elif len(j) > 2:

o += "," + repl + ("%#x" % (int(m.group(1), 0) << j[2]))

else:

o += "," + repl + m.group(1)

flags = flags[m.end():]

if flags == "":

break

if flags[0:1] == ":":

flags = flags[1:]

else:

if flags != "":

if len(extra_map) > 0:

print("Uncore cannot parse", flags, file=sys.stderr)

break

def __init__(self, name, row):

self.name = name

e = self

if 'PublicDescription' in row:

e.desc = row['PublicDescription'].strip()

elif 'BriefDescription' in row:

e.desc = row['BriefDescription'].strip()

else:

e.desc = row['Description'].strip()

e.code = int(row['EventCode'], 16)

if 'Internal' in row and int(row['Internal']) != 0:

e.code |= int(row['Internal']) << 21

e.umask = int(row['UMask'], 16)

e.cmask = int_or_zero(row, 'CounterMask')

e.inv = int_or_zero(row, 'Invert')

e.edge = int_or_zero(row, 'EdgeDetect')

e.unit = row['Unit'].lower()

if e.unit in uncore_units:

e.unit = uncore_units[e.unit]

if e.unit == "ncu":

e.unit = "clock" if box_exists("clock") else "cbox"

e.umask = 0

e.code = 0xff

# xxx subctr

if e.unit in box_to_perf:

e.unit = box_to_perf[e.unit]

e.msr = None

e.overflow = 0

e.counter = "1" # dummy for toplev

e.newextra = ""

if 'Errata' in row:

e.errata = row['Errata']

else:

e.errata = None

self.extra = ''

self.userextra = ''

# {

# "Unit": "CBO",

# "EventCode": "0x22",

# "UMask": "0x21",

# "EventName": "UNC_CBO_XSNP_RESPONSE.MISS_EXTERNAL",

# "Description": "An external snoop misses in some processor core.",

# "Counter": "0,1",

# "CounterMask": "0",

# "Invert": "0",

# "EdgeDetect": "0"

# },

# XXX cannot separate sockets

# extra: perf flags

# flags: emon flags

def output_newstyle(self, newextra="", noname=False, period=False, name="", flags="", noexplode=False):

e = self

o = "/event=%#x" % e.code

if e.umask:

o += ",umask=%#x" % e.umask

if e.cmask:

o += ",cmask=%#x" % e.cmask

if e.edge:

o += ",edge=1"

if e.inv:

o += ",inv=1"

if e.newextra:

if flags:

flags += ","

flags += e.newextra

one_unit = "one_unit" in flags

if has_format_any("cmask", "uncore_" + e.unit):

extra_map = uncore_map_cmask

else:

extra_map = uncore_map_thresh

o += convert_uncore(flags, extra_map)

# xxx subctr, occ_sel, filters

if version.has_name and not noname:

if name == "":

name = gen_name(e.name, False)

o += ",name=" + name + "_NUM"

if newextra:

o += "," + ",".join(newextra)

o += "/"

# explode boxes if needed

def box_name(n):

return "%s_%d" % (e.unit, n)

def box_n_exists(n):

if one_unit and n > 0:

return False

return box_exists(box_name(n))

if not noexplode and not box_exists(e.unit) and box_n_exists(0):

return ",".join(["uncore_" + box_name(x) + o.replace("_NUM", "_%d" % (x)) for x in

itertools.takewhile(box_n_exists, itertools.count())])

return "uncore_%s%s" % (e.unit, o.replace("_NUM", ""))

def filter_qual(self):

def check_qual(q):

if q == "":

return False

if q == "one_unit":

return True

if "=" in q:

q, _ = q.split("=")

if has_format_any(q, "uncore_" + self.unit):

return True

warn_once("%s: format %s not supported. Filtering out" % (self.unit, q))

return False

self.newextra = ",".join(filter(check_qual, convert_uncore(self.newextra, ()).split(",")))

assert flag != 0

m = 1

j = 0

while (flag & m) == 0:

m = m << 1

j += 1

m = a | b

if 'ppp' in m:

m = m - set(['p', 'pp'])

if 'pp' in m:

m = m - set(['p'])

m = m - set([':'])

desc = "".join([y for y in desc if y < chr(127)])

print(" %-42s" % (name,), end='', file=f)

if pmu:

print(" [%s]" % pmu, end='', file=f)

if human:

print("\n%s" % (wrap.fill(desc),), file=f)

else:

if file_exists("/sys/devices/uncore_" + box + postfix):

return True

if file_exists("/sys/devices/uncore_" + box + "_0" + postfix):

return True

if uncore_exists(e.unit):

if e.cmask and not uncore_exists(e.unit, "/format/cmask"):

warn_once("Uncore unit " + e.unit + " missing cmask for " + e.name)

extramsg.append("not supported due to missing cmask in PMU")

return None

if e.umask and not uncore_exists(e.unit, "/format/umask"):

warn_once("Uncore unit " + e.unit + " missing umask for " + e.name)

extramsg.append("not supported due to missing umask in PMU")

return None

return e

if e.unit not in missing_boxes:

warn_once("Uncore unit " + e.unit + " missing")

missing_boxes.add(e.unit)

extramsg.append("not supported due to missing PMU")

"inst_retired.any": (0xc0, 0, 0),

"cpu_clk_unhalted.thread": (0x3c, 0, 0),

"cpu_clk_unhalted.thread_any": (0x3c, 0, 1),

"cpu_clk_unhalted.core": (0x3c, 0, 1),

if ev:

ev = copy.deepcopy(ev)

ev.name = name

if ocverbose:

print("open", name, file=sys.stderr)

d = open(name, "rb").read()

if not isinstance(d, str):

d = d.decode('utf-8')

json_data = json.loads(d)

if isinstance(json_data, dict) and 'Events' in json_data:

json_data = json_data['Events']

"""Read an event table."""

def __init__(self, name, pmu):

self.events = {}

self.perf_events = {}

self.codes = {}

self.desc = {}

self.pevents = {}

self.latego = False

self.uncore_events = {}

self.error = False

self.pmu = pmu

self.read_events(name)

def add_event(self, e):

self.events[e.name] = e

self.perf_events[e.name.replace('.', '_')] = e # workaround for perf-style naming

if e.pname:

self.pevents[e.pname] = e

self.codes[e.val] = e

self.desc[e.name] = e.desc

e.pmu = self.pmu

def read_table(self, r):

for row in r:

def get(x):

return row[x]

def gethex(x):

return int(get(x).split(",")[0], 16)

def getdec(x):

return int(get(x), 10)

name = get(u'EventName').lower().rstrip()

try:

code = gethex(u'EventCode')

umask = gethex(u'UMask')

except ValueError:

if ocverbose:

print("cannot parse event", name)

continue

anyf = 0

if name in fixed_counters:

code, umask, anyf = fixed_counters[name]

if u'Other' in row:

other = gethex(u'Other') << 16

else:

other = 0

other |= gethex(u'EdgeDetect') << 18

if u'AnyThread' in row:

other |= (gethex(u'AnyThread') | anyf) << 21

other |= getdec(u'CounterMask') << 24

other |= gethex(u'Invert') << 23

val = code | (umask << 8) | other

val &= EVMASK

d = get(u'PublicDescription')

if d is None:

d = ''

d = d.strip()

e = Event(name, val, d)

e.newextra = ""

if other & ((1 << 16)|(1 << 17)):

if other & (1<<16):

e.extra += "u"

if other & (1 << 17):

e.extra += "k"

e.perfqual = None

if u'MSRIndex' in row and get(u'MSRIndex') and get(u'MSRValue'):

msrnum = gethex(u'MSRIndex')

msrval = gethex(u'MSRValue')

if version.offcore and msrnum in (0x1a6, 0x1a7):

e.newextra = ",offcore_rsp=0x%x" % (msrval, )

e.perfqual = "offcore_rsp"

elif version.ldlat and msrnum in (0x3f6,):

e.newextra = ",ldlat=0x%x" % (msrval, )

e.perfqual = "ldlat"

elif msrnum == 0x3f7:

e.newextra = ",frontend=%#x" % (msrval, )

e.perfqual = "frontend"

# add new msr here

else:

e.msrval = msrval

e.msr = msrnum

if u'SampleAfterValue' in row:

e.overflow = get(u'SampleAfterValue')

e.counter = get(u'Counter')

e.precise = getdec(u'Precise') if u'Precise' in row else 0

e.collectpebs = getdec(u'CollectPEBS') if u'CollectPEBS' in row else 0

e.pebs = getdec(u'PEBS') if u'PEBS' in row else 0

if e.collectpebs > 1 or e.pebs >= 2:

e.extra += "pp"

if len(e.counter.split(",")) == 1:

e.extra += "p"

try:

if get(u'Errata') != "null":

try:

d += " Errata: "

d += get(u'Errata')

e.errata = get(u'Errata')

except UnicodeDecodeError:

pass

except KeyError:

pass

e.desc = d

for (flag, name) in extra_flags:

if val & flag:

e.newextra += ",%s=%d" % (name, (val & flag) >> ffs(flag), )

e.period = int(get(u'SampleAfterValue')) if u'SampleAfterValue' in row else 0

self.add_event(e)

def getevent(self, e, nocheck=False, extramsg=[]):

"""Retrieve an event with name e. Return Event object or None.

When nocheck is set don't check against current system."""

e = e.lower()

extra = ""

edelim = ""

m = re.match(r'([^:]+):request=([^:]+):response=([^:]+)', e)

if m:

ename = m.group(1) + "." + m.group(2) + "." + m.group(3)

return update_ename(self.getevent(ename, nocheck=nocheck, extramsg=extramsg), e)

m = re.match(r'(.*?):(.*)', e)

if m:

extra = m.group(2)

edelim = ":"

e = m.group(1)

if e in self.events:

# hack for now. Avoid ambiguity with :p

# Should handle qualmap properly here

extra = extra.replace("period=", "sample-after=")

userextra = extra

extra = extra_set(extra)

ev = self.events[e]

ev_extra = extra_set(ev.extra)

if extra and merge_extra(ev_extra, extra) > ev_extra:

ev = copy.deepcopy(self.events[e])

ev.userextra = userextra

ev.extra = "".join(sorted(merge_extra(ev_extra, extra)))

return ev

return self.events[e]

elif e.endswith("_ps"):

return update_ename(self.getevent(e[:-3] + ":p" + extra), e)

elif e.startswith("offcore") and (e + "_0") in self.events:

return update_ename(self.getevent(e + "_0" + edelim + extra), e)

elif e in self.uncore_events:

ev = self.uncore_events[e]

if ev and not nocheck:

ev = check_uncore_event(ev, extramsg)

if ev and extra:

ev = copy.deepcopy(ev)

ev.newextra = extra

return ev

elif e in self.perf_events:

return self.perf_events[e]

elif e in self.pevents:

return self.pevents[e]

extramsg.append("event not found for %s" % self.pmu)

return None

# XXX need to handle exploded events

def update_event(self, e, ev):

if e not in self.pevents:

self.pevents[e] = ev

def getraw(self, r):

e = "r%x" % (r)

if e in self.pevents:

ev = self.pevents[e]

s = ev.name

if ev.extra:

s += ":" + ev.extra

return s

return "!Raw 0x%x" % (r,)

def getperf(self, p):

if p in self.pevents:

e = self.pevents[p]

n = e.name

if e.userextra:

n += ":" + e.userextra

return n

return p

def dumpevents(self, f=sys.stdout, human=True, uncore=True):

"""Print all events with descriptions to the file descriptor f.

When human is true word wrap all the descriptions."""

wrap = None

if human:

wrap = textwrap.TextWrapper(initial_indent=" ",

subsequent_indent=" ")

for k in sorted(self.events.keys()):

print_event(k, self.desc[k], f, human, wrap, self.pmu)

if uncore:

for k in sorted(self.uncore_events.keys()):

print_event(k, self.uncore_events[k].desc, f, human, wrap)

def read_events(self, name):

"""Read JSON normal events table."""

if name.find("JKT") >= 0 or name.find("Jaketown") >= 0:

self.latego = True

try:

data = json_open(name)

except ValueError as e:

print("Cannot parse", name + ":", e.message, file=sys.stderr)

self.error = True

return

self.read_table(data)

if "topdown.slots" in self.events:

self.add_topdown()

def add_offcore(self, name):

"""Read offcore table."""

data = json_open(name)

# {

# "MATRIX_REQUEST": "DEMAND_DATA_RD",

# "MATRIX_RESPONSE": "NULL",

# "MATRIX_VALUE": "0x0000000001",

# "MATRIX_REGISTER": "0,1",

# "DESCRIPTION": "Counts demand data reads that"

# },

offcore_response = self.getevent("OFFCORE_RESPONSE")

if not offcore_response:

return

requests = []

responses = []

for row in data:

if row[u"MATRIX_REQUEST"].upper() != "NULL":

requests.append((row[u"MATRIX_REQUEST"], row[u"MATRIX_VALUE"], row[u"DESCRIPTION"]))

if row[u"MATRIX_RESPONSE"].upper() != "NULL":

responses.append((row[u"MATRIX_RESPONSE"], row[u"MATRIX_VALUE"], row[u"DESCRIPTION"]))

def create_event(req_name, req_val, req_desc, res_name, res_val, res_desc):

oe = copy.deepcopy(offcore_response)

oe.name = ("OFFCORE_RESPONSE.%s.%s" % (req_name, res_name)).lower()

if oe.name.lower() in self.events:

return

oe.msrval = int(req_val, 16) | (int(res_val, 16) << 16)

oe.desc = req_desc + " " + res_desc

if version.offcore:

oe.newextra = ",offcore_rsp=0x%x" % (oe.msrval, )

else:

oe.msr = 0x1a6

self.add_event(oe)

for a, b in itertools.product(requests, responses):

create_event(*(a + b))

def add_uncore(self, name, force=False):

data = json_open(name)

for row in data:

name = row['EventName'].lower()

try:

self.uncore_events[name] = UncoreEvent(name, row)

except UnicodeEncodeError:

pass

def add_topdown(self):

def td_event(name, pname, desc, counter):

e = Event(name, 0, desc)

e.counter = counter

e.pname = pname

self.add_event(e)

td_event("perf_metrics.retiring", "topdown-retiring", "Number of slots the pipeline was frontend bound.", "32")

td_event("perf_metrics.bad_speculation", "topdown-bad-spec", "Number of slots the pipeline was doing bad speculation.", "33")

td_event("perf_metrics.frontend_bound", "topdown-fe-bound", "Number of slots the pipeline was frontend bound.", "34")

td_event("perf_metrics.backend_bound", "topdown-be-bound", "Number of slots the pipeline was backend bound.", "35")

td_event("topdown.slots", "slots", "Number of slots", "36")

if "topdown.memory_bound_slots" in self.events:

td_event("perf_metrics.heavy_operations", "topdown-heavy-ops", "Number of slots pipeline retired microcode instructions with >2 uops", "36")

td_event("perf_metrics.branch_mispredicts", "topdown-br-mispredict", "Number of slots frontend was bound by branch mispredictions", "37")

td_event("perf_metrics.memory_bound", "topdown-mem-bound", "Number of slots backend was bound by memory", "38")

"cpu_core": ("hybridcore", "Core"),

"cpu_atom": ("hybridcore", "Atom"),

"cpu": ("core", None),

typ = pmu_to_type[pmu]

name = event_download.eventlist_name(el, key=typ[0], hybridkey=typ[1])

if not os.path.exists(name):

if pmu == "cpu_core":

name = event_download.eventlist_name(el, "core")

else:

name = event_download.eventlist_name(el, "hybridcore", hybridkey="Core")

emap = EmapNativeJSON(name, pmu)

if not emap or emap.error:

print("parsing", name, "failed", file=sys.stderr)

return None

if experimental:

try:

emap.read_events(event_download.eventlist_name(el, "core experimental"))

except IOError:

pass

add_extra_env(emap, el, eventmap_is_file)

try:

oc = os.getenv("OFFCORE")

if oc:

oc = canon_emapvar(oc, "matrix")

oc = event_download.eventlist_name(el, "offcore")

emap.add_offcore(oc)

elif not eventmap_is_file:

oc = event_download.eventlist_name(el, "offcore")

if os.path.exists(oc) and el != oc:

emap.add_offcore(oc)

if experimental:

oc = event_download.eventlist_name(el, "offcore experimental")

if os.path.exists(oc) and oc != el:

emap.add_offcore(oc)

except IOError:

print("Cannot open offcore", oc, file=sys.stderr)

try:

uc = os.getenv("UNCORE")

if uc:

uc = canon_emapvar(uc, "uncore")

uc = event_download.eventlist_name(uc, "uncore")

emap.add_uncore(uc)

elif not eventmap_is_file:

uc = event_download.eventlist_name(el, "uncore")

if os.path.exists(uc) and uc != el:

emap.add_uncore(uc)

if experimental:

uc = event_download.eventlist_name(el, "uncore experimental")

if os.path.exists(uc) and uc != el:

emap.add_uncore(uc)

except IOError:

print("Cannot open uncore", uc, file=sys.stderr)

def read_map(env, typ, r):

try:

e2 = os.getenv(env)

if e2:

e2 = canon_emapvar(e2, typ)

r(e2)

# don't try to download for now

except IOError:

print("Cannot open " + env, e2, file=sys.stderr)

read_map("EVENTMAP2", "core", emap.read_events)

read_map("EVENTMAP3", "core", emap.read_events)

if ("*" in el or "." in el or "_" in el) and "/" not in el and not file_exists(el):

el = "%s/%s" % (event_download.getdir(), el)

if '*' in el:

l = glob.glob(el)

if l:

if len(l) > 1:

l = [x for x in l if x.find(typ) >= 0]

if l:

el = l[0]

"""Search and read a perfmon event map.

When the EVENTMAP environment variable is set read that, otherwise

read the map for the current CPU. EVENTMAP can be a CPU specifier

in the map file or a path name.

Dito for the OFFCORE and UNCORE environment variables.

Optionally pass the name of the EVENTMAP variable, and the cpu pmu name.

Return an emap object that contains the events and can be queried

or None if nothing is found or the current CPU is unknown."""

el = os.getenv(eventvar)

if not el:

eventmap_is_file = False

el = event_download.get_cpustr()

else:

eventmap_is_file = "/" in el

el = canon_emapvar(el, "core")

if "/" in el:

try:

emap = EmapNativeJSON(el, pmu)

if not emap or emap.error:

return None

add_extra_env(emap, el, eventmap_is_file)

return emap

except IOError:

return None

try:

if not force_download:

return json_with_extra(el, eventmap_is_file, pmu)

except IOError:

pass

try:

toget = ["core"]

if not os.getenv("OFFCORE"):

toget.append("offcore")

if not os.getenv("UNCORE"):

toget.append("uncore")

if experimental:

toget += [x + " experimental" for x in toget]

event_download.download(el, toget)

return json_with_extra(el, eventmap_is_file, pmu)

except IOError:

pass

overflow = None

# replace inner commas so we can split events

event = re.sub(r"([a-z][a-z0-9]+/)([^/]+)/",

lambda m: m.group(1) + m.group(2).replace(",", "#") + "/",

event)