EIC code displayed by LXR master/​swf-monitor/​src/​monitor_app/​es_plot.py	Source navigation Diff markup Identifier search General search
	Version: master test Revert   Change

File indexing completed on 2026-11-09 10:47:33

 """The core occupancy plot of an Event Service job: one lane per core the
 job works (one single-threaded payload instance each)
 along the job's own clock. Measured initialization, event processing and
 setup/output handling have distinct segments; legacy aggregate time stays
 unseparated. Processing carries its output outcome (green saved, red failed; after a sudden end, light
 yellow the processing cut off and dark yellow the units whose output
 never left the node), each core's processed events at its right and their total on the closes
 lane, the closes on their own lane, the harness's span, the pilot's head and
 tail as the bare lanes before the first unit and after the last. What
 the job's cores were doing every minute of its life, and what they were not
 (swf-epicprod NODE_EVENT_DISPATCHER.md, The record). Inline SVG, no
 script, legible in both themes.
 """
 from django.utils.html import escape
 from django.utils.safestring import mark_safe
 
 LEFT = 70          # the lane labels
 RIGHT = 90         # each core's events
 WIDTH = 1000
 LANE_H = 20
 AXIS_H = 34
 TOP = 8
 
 DONE = '#2e8b57'
 FAILED = '#c0392b'
 CLOSE = '#3a7bd5'
 HARNESS = '#8e6bbf'
 INTERRUPTED = '#f5d76e'   # processing cut off by a sudden end (preemption)
 UNSHIPPED = '#d49a00'     # finished, its output never left the node
 RUNNING = '#7fc8a9'       # an allocation's job still running
 UNIT_COLOR = {'done': DONE, 'failed': FAILED, 'interrupted': INTERRUPTED, 'unshipped': UNSHIPPED,
               'running': RUNNING, 'awaiting': '#879d66'}
 IDLE = 'rgba(128,128,128,0.18)'
 INITIALIZATION = '#d97706'
 OVERHEAD = '#64748b'
 UNSEPARATED = '#8a7f91'
 
 
 def _tick_step(wall_s):
     """The minute step of the axis ticks for a wall of wall_s seconds."""
     minutes = wall_s / 60.0
     for step in (1, 2, 5, 10, 15, 30, 60, 120, 240):
         if minutes / step <= 12:
             return step
     return 480
 
 
 def slot_plot_svg(tl):
     """The SVG for a timeline from queries.es_slot_timeline, or ''.
 
     queries.allocation_timeline gives the same shape for a batch
     allocation's jobs, with optional keys: ``lane_label`` (default
     'core'), ``closes_lane`` False to omit the closes lane, a row's
     ``right_text`` and the timeline's ``total_text`` in place of the
     events counts, and a unit's ``title`` in place of the default hover
     text; ``compact_lanes`` narrows the lanes and labels every eighth."""
     if not tl or not tl.get('wall_s'):
         return ''
     wall = float(tl['wall_s'])
     rows = list(tl.get('rows') or [])
     closes_lane = tl.get('closes_lane', True)
     lane_label = tl.get('lane_label') or 'core'
     lanes = len(rows) + (1 if closes_lane else 0)
     compact = bool(tl.get('compact_lanes'))
     LANE_H = 8 if compact else 20
     label_every = 8 if compact else 1
     height = TOP + lanes * LANE_H + AXIS_H
     plot_w = WIDTH - LEFT - RIGHT
     pad = 1 if compact else 3
     label_dy = LANE_H / 2 + 5 if compact else LANE_H * 0.72
 
     def x(t):
         return LEFT + max(0.0, min(1.0, t / wall)) * plot_w
 
     parts = [f'<svg viewBox="0 0 {WIDTH} {height}" width="100%" height="{height}" '
              f'role="img" aria-label="core occupancy" style="font-family:inherit;font-size:14px;max-width:100%">']
     # Lanes: the idle band the whole job long, then the units.
     for i, row in enumerate(rows):
         y = TOP + i * LANE_H
         # Compact lanes are labelled every eighth, the label centred on its lane.
         if i % label_every == 0:
             # A pool member's lane carries its own label (reco N).
             label = row.get('label') or f"{lane_label} {row['index']}"
             parts.append(f'<text x="{LEFT - 8}" y="{y + label_dy:.1f}" text-anchor="end" fill="currentColor">'
                          f'{escape(label)}</text>')
         parts.append(f'<rect x="{LEFT}" y="{y + pad}" width="{plot_w:.1f}" height="{LANE_H - 2 * pad}" fill="{IDLE}"/>')
         for u in row['units']:
             x0, x1 = x(u['start_s']), x(u['end_s'])
             color = UNIT_COLOR.get(u['status'], FAILED)
             title = escape(u.get('title') or (
                 f"{u.get('unit_id') or 'unit'}: {u['status']}, {u.get('events') or 0} events, "
                 f"{(u['end_s'] - u['start_s']) / 60:.1f} min from {u['start_s'] / 60:.1f} min"
                 + (f"; output shipped in close {u['close']}" if u.get('close') else '')))
             segments = u.get('segments')
             if segments:
                 for segment in segments:
                     phase = segment['phase']
                     a, b = x(segment['start_s']), x(segment['end_s'])
                     fill = (INITIALIZATION if phase == 'initialization' else
                             OVERHEAD if phase == 'overhead' else
                             UNSEPARATED if phase == 'unseparated' else color)
                     label = {'initialization': 'initialization', 'overhead': 'setup / output handling',
                              'unseparated': 'unit time; initialization and processing not separately measured',
                              'simulation': 'simulation events', 'reconstruction': 'reconstruction events'}[phase]
                     detail = escape(f"{label}: {segment['end_s'] - segment['start_s']:.2f} s; ")
                     parts.append(f'<rect x="{a:.1f}" y="{y + pad}" width="{max(.2, b - a):.1f}" '
                                  f'height="{LANE_H - 2 * pad}" fill="{fill}"><title>{detail}{title}</title></rect>')
             else:
                 parts.append(f'<rect x="{x0:.1f}" y="{y + pad}" width="{max(1.5, x1 - x0):.1f}" height="{LANE_H - 2 * pad}" '
                              f'fill="{color}"><title>{title}</title></rect>')
             # A slim white line where the unit starts: consecutive units
             # on a core read as one bar without it.
             if x1 - x0 >= 3:
                 parts.append(f'<line x1="{x0:.1f}" y1="{y + pad}" x2="{x0:.1f}" y2="{y + LANE_H - pad}" '
                              f'stroke="#fff" stroke-width="1"/>')
         # The events the core processed: unequal counts show the stream
         # filling each core by its own pace.
         if 'right_text' in row:
             right = row['right_text']
         else:
             n = sum(int(u.get('events') or 0) for u in row['units'] if u['status'] == 'done')
             right = f'{n:,} ev'
         if right and i % label_every == 0:
             parts.append(f'<text x="{WIDTH - 4}" y="{y + label_dy:.1f}" text-anchor="end" fill="currentColor">'
                          f'{escape(right)}</text>')
     if closes_lane:
         # The closes lane.
         y = TOP + len(rows) * LANE_H
         total = sum(int(u.get('events') or 0) for row in rows for u in row['units'] if u['status'] == 'done')
         parts.append(f'<text x="{WIDTH - 4}" y="{y + LANE_H * 0.72:.1f}" text-anchor="end" fill="currentColor" '
                      f'font-weight="bold">{total:,} ev</text>')
         parts.append(f'<text x="{LEFT - 8}" y="{y + LANE_H * 0.72:.1f}" text-anchor="end" fill="currentColor">closes</text>')
         parts.append(f'<rect x="{LEFT}" y="{y + 3}" width="{plot_w:.1f}" height="{LANE_H - 6}" fill="{IDLE}"/>')
         for c in tl.get('closes') or []:
             x0, x1 = x(c['start_s']), x(c['end_s'])
             outcome = 'running' if c.get('running') else 'registered' if c.get('ok') else 'failed'
             title = escape(f"close {c.get('index')}: {outcome}, "
                            f"{(c['end_s'] - c['start_s']):.0f} s from {c['start_s'] / 60:.1f} min")
             parts.append(f'<rect x="{x0:.1f}" y="{y + 3}" width="{max(2.0, x1 - x0):.1f}" height="{LANE_H - 6}" '
                          f'fill="{CLOSE if c.get("ok") or c.get("running") else FAILED}"><title>{title}</title></rect>')
     # The cut of a preemption: a red line through the lanes.
     if tl.get('cut_s') is not None:
         xc = x(tl['cut_s'])
         label = 'preempted' if tl.get('cut_real') else 'cut (test)'
         parts.append(f'<line x1="{xc:.1f}" y1="{TOP}" x2="{xc:.1f}" y2="{TOP + lanes * LANE_H}" '
                      f'stroke="{FAILED}" stroke-width="2"><title>{label} at {tl["cut_s"] / 60:.1f} min</title></line>')
     # The harness's span, a thin line under the lanes.
     h = tl.get('harness')
     y_axis = TOP + lanes * LANE_H
     if h and h.get('start_s') is not None:
         x0 = x(h['start_s'])
         x1 = x(h['end_s']) if h.get('end_s') is not None else x(wall)
         parts.append(f'<rect x="{x0:.1f}" y="{y_axis + 2}" width="{max(1.0, x1 - x0):.1f}" height="3" fill="{HARNESS}">'
                      f'<title>harness running: {h["start_s"] / 60:.1f} to {(h["end_s"] or wall) / 60:.1f} min</title></rect>')
     # The axis: minutes from the pilot's start of the job.
     step = _tick_step(wall)
     parts.append(f'<line x1="{LEFT}" y1="{y_axis + 8}" x2="{WIDTH - RIGHT}" y2="{y_axis + 8}" stroke="currentColor" stroke-opacity="0.5"/>')
     m = 0
     while m * 60 <= wall + 1e-6:
         xt = x(m * 60)
         parts.append(f'<line x1="{xt:.1f}" y1="{y_axis + 8}" x2="{xt:.1f}" y2="{y_axis + 13}" stroke="currentColor" stroke-opacity="0.5"/>')
         parts.append(f'<text x="{xt:.1f}" y="{y_axis + 27}" text-anchor="middle" fill="currentColor">{m}</text>')
         m += step
     parts.append(f'<text x="{WIDTH - 4}" y="{y_axis + 27}" text-anchor="end" fill="currentColor" fill-opacity="0.7">min</text>')
     parts.append('</svg>')
     return mark_safe(''.join(parts))

This page was automatically generated by the 2.3.7 LXR engine. The LXR team