drivers/gpu/arm/midgard_for_linux/mali_kbase_trace_timeline.h

   1 /*
   2  *
   3  * (C) COPYRIGHT 2012-2016 ARM Limited. All rights reserved.
   4  *
   5  * This program is free software and is provided to you under the terms of the
   6  * GNU General Public License version 2 as published by the Free Software
   7  * Foundation, and any use by you of this program is subject to the terms
   8  * of such GNU licence.
   9  *
  10  * A copy of the licence is included with the program, and can also be obtained
  11  * from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  12  * Boston, MA  02110-1301, USA.
  13  *
  14  */
  15
  16
  17
  18
  19
  20 #if !defined(_KBASE_TRACE_TIMELINE_H)
  21 #define _KBASE_TRACE_TIMELINE_H
  22
  23 #ifdef CONFIG_MALI_TRACE_TIMELINE
  24
  25 enum kbase_trace_timeline_code {
  26         #define KBASE_TIMELINE_TRACE_CODE(enum_val, desc, format, format_desc) enum_val
  27         #include "mali_kbase_trace_timeline_defs.h"
  28         #undef KBASE_TIMELINE_TRACE_CODE
  29 };
  30
  31 /** Initialize Timeline DebugFS entries */
  32 void kbasep_trace_timeline_debugfs_init(struct kbase_device *kbdev);
  33
  34 /* mali_timeline.h defines kernel tracepoints used by the KBASE_TIMELINE
  35  * functions.
  36  * Output is timestamped by either sched_clock() (default), local_clock(), or
  37  * cpu_clock(), depending on /sys/kernel/debug/tracing/trace_clock */
  38 #include "mali_timeline.h"
  39
  40 /* Trace number of atoms in flight for kctx (atoms either not completed, or in
  41    process of being returned to user */
  42 #define KBASE_TIMELINE_ATOMS_IN_FLIGHT(kctx, count)                          \
  43         do {                                                                 \
  44                 struct timespec ts;                                          \
  45                 getrawmonotonic(&ts);                                        \
  46                 trace_mali_timeline_atoms_in_flight(ts.tv_sec, ts.tv_nsec,   \
  47                                 (int)kctx->timeline.owner_tgid,              \
  48                                 count);                                      \
  49         } while (0)
  50
  51 /* Trace atom_id being Ready to Run */
  52 #define KBASE_TIMELINE_ATOM_READY(kctx, atom_id)                             \
  53         do {                                                                 \
  54                 struct timespec ts;                                          \
  55                 getrawmonotonic(&ts);                                        \
  56                 trace_mali_timeline_atom(ts.tv_sec, ts.tv_nsec,              \
  57                                 CTX_FLOW_ATOM_READY,                         \
  58                                 (int)kctx->timeline.owner_tgid,              \
  59                                 atom_id);                                    \
  60         } while (0)
  61
  62 /* Trace number of atoms submitted to job slot js
  63  *
  64  * NOTE: This uses a different tracepoint to the head/next/soft-stop actions,
  65  * so that those actions can be filtered out separately from this
  66  *
  67  * This is because this is more useful, as we can use it to calculate general
  68  * utilization easily and accurately */
  69 #define KBASE_TIMELINE_ATOMS_SUBMITTED(kctx, js, count)                      \
  70         do {                                                                 \
  71                 struct timespec ts;                                          \
  72                 getrawmonotonic(&ts);                                        \
  73                 trace_mali_timeline_gpu_slot_active(ts.tv_sec, ts.tv_nsec,   \
  74                                 SW_SET_GPU_SLOT_ACTIVE,                      \
  75                                 (int)kctx->timeline.owner_tgid,              \
  76                                 js, count);                                  \
  77         } while (0)
  78
  79
  80 /* Trace atoms present in JS_NEXT */
  81 #define KBASE_TIMELINE_JOB_START_NEXT(kctx, js, count)                       \
  82         do {                                                                 \
  83                 struct timespec ts;                                          \
  84                 getrawmonotonic(&ts);                                        \
  85                 trace_mali_timeline_gpu_slot_action(ts.tv_sec, ts.tv_nsec,   \
  86                                 SW_SET_GPU_SLOT_NEXT,                        \
  87                                 (int)kctx->timeline.owner_tgid,              \
  88                                 js, count);                                  \
  89         } while (0)
  90
  91 /* Trace atoms present in JS_HEAD */
  92 #define KBASE_TIMELINE_JOB_START_HEAD(kctx, js, count)                       \
  93         do {                                                                 \
  94                 struct timespec ts;                                          \
  95                 getrawmonotonic(&ts);                                        \
  96                 trace_mali_timeline_gpu_slot_action(ts.tv_sec, ts.tv_nsec,   \
  97                                 SW_SET_GPU_SLOT_HEAD,                        \
  98                                 (int)kctx->timeline.owner_tgid,              \
  99                                 js, count);                                  \
 100         } while (0)
 101
 102 /* Trace that a soft stop/evict from next is being attempted on a slot */
 103 #define KBASE_TIMELINE_TRY_SOFT_STOP(kctx, js, count) \
 104         do {                                                                 \
 105                 struct timespec ts;                                          \
 106                 getrawmonotonic(&ts);                                        \
 107                 trace_mali_timeline_gpu_slot_action(ts.tv_sec, ts.tv_nsec,   \
 108                                 SW_SET_GPU_SLOT_STOPPING,                    \
 109                                 (kctx) ? (int)kctx->timeline.owner_tgid : 0, \
 110                                 js, count);                                  \
 111         } while (0)
 112
 113
 114
 115 /* Trace state of overall GPU power */
 116 #define KBASE_TIMELINE_GPU_POWER(kbdev, active)                              \
 117         do {                                                                 \
 118                 struct timespec ts;                                          \
 119                 getrawmonotonic(&ts);                                        \
 120                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,  \
 121                                 SW_SET_GPU_POWER_ACTIVE, active);            \
 122         } while (0)
 123
 124 /* Trace state of tiler power */
 125 #define KBASE_TIMELINE_POWER_TILER(kbdev, bitmap)                            \
 126         do {                                                                 \
 127                 struct timespec ts;                                          \
 128                 getrawmonotonic(&ts);                                        \
 129                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,  \
 130                                 SW_SET_GPU_POWER_TILER_ACTIVE,               \
 131                                 hweight64(bitmap));                          \
 132         } while (0)
 133
 134 /* Trace number of shaders currently powered */
 135 #define KBASE_TIMELINE_POWER_SHADER(kbdev, bitmap)                           \
 136         do {                                                                 \
 137                 struct timespec ts;                                          \
 138                 getrawmonotonic(&ts);                                        \
 139                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,  \
 140                                 SW_SET_GPU_POWER_SHADER_ACTIVE,              \
 141                                 hweight64(bitmap));                          \
 142         } while (0)
 143
 144 /* Trace state of L2 power */
 145 #define KBASE_TIMELINE_POWER_L2(kbdev, bitmap)                               \
 146         do {                                                                 \
 147                 struct timespec ts;                                          \
 148                 getrawmonotonic(&ts);                                        \
 149                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,  \
 150                                 SW_SET_GPU_POWER_L2_ACTIVE,                  \
 151                                 hweight64(bitmap));                          \
 152         } while (0)
 153
 154 /* Trace state of L2 cache*/
 155 #define KBASE_TIMELINE_POWERING_L2(kbdev)                                    \
 156         do {                                                                 \
 157                 struct timespec ts;                                          \
 158                 getrawmonotonic(&ts);                                        \
 159                 trace_mali_timeline_l2_power_active(ts.tv_sec, ts.tv_nsec,   \
 160                                 SW_FLOW_GPU_POWER_L2_POWERING,               \
 161                                 1);                                          \
 162         } while (0)
 163
 164 #define KBASE_TIMELINE_POWERED_L2(kbdev)                                     \
 165         do {                                                                 \
 166                 struct timespec ts;                                          \
 167                 getrawmonotonic(&ts);                                        \
 168                 trace_mali_timeline_l2_power_active(ts.tv_sec, ts.tv_nsec,   \
 169                                 SW_FLOW_GPU_POWER_L2_ACTIVE,                 \
 170                                 1);                                          \
 171         } while (0)
 172
 173 /* Trace kbase_pm_send_event message send */
 174 #define KBASE_TIMELINE_PM_SEND_EVENT(kbdev, event_type, pm_event_id)         \
 175         do {                                                                 \
 176                 struct timespec ts;                                          \
 177                 getrawmonotonic(&ts);                                        \
 178                 trace_mali_timeline_pm_event(ts.tv_sec, ts.tv_nsec,          \
 179                                 SW_FLOW_PM_SEND_EVENT,                       \
 180                                 event_type, pm_event_id);                    \
 181         } while (0)
 182
 183 /* Trace kbase_pm_worker message receive */
 184 #define KBASE_TIMELINE_PM_HANDLE_EVENT(kbdev, event_type, pm_event_id)       \
 185         do {                                                                 \
 186                 struct timespec ts;                                          \
 187                 getrawmonotonic(&ts);                                        \
 188                 trace_mali_timeline_pm_event(ts.tv_sec, ts.tv_nsec,          \
 189                                 SW_FLOW_PM_HANDLE_EVENT,                     \
 190                                 event_type, pm_event_id);                    \
 191         } while (0)
 192
 193
 194 /* Trace atom_id starting in JS_HEAD */
 195 #define KBASE_TIMELINE_JOB_START(kctx, js, _consumerof_atom_number)          \
 196         do {                                                                 \
 197                 struct timespec ts;                                          \
 198                 getrawmonotonic(&ts);                                        \
 199                 trace_mali_timeline_slot_atom(ts.tv_sec, ts.tv_nsec,         \
 200                                 HW_START_GPU_JOB_CHAIN_SW_APPROX,            \
 201                                 (int)kctx->timeline.owner_tgid,              \
 202                                 js, _consumerof_atom_number);                \
 203         } while (0)
 204
 205 /* Trace atom_id stopping on JS_HEAD */
 206 #define KBASE_TIMELINE_JOB_STOP(kctx, js, _producerof_atom_number_completed) \
 207         do {                                                                 \
 208                 struct timespec ts;                                          \
 209                 getrawmonotonic(&ts);                                        \
 210                 trace_mali_timeline_slot_atom(ts.tv_sec, ts.tv_nsec,         \
 211                                 HW_STOP_GPU_JOB_CHAIN_SW_APPROX,             \
 212                                 (int)kctx->timeline.owner_tgid,              \
 213                                 js, _producerof_atom_number_completed);      \
 214         } while (0)
 215
 216 /** Trace beginning/end of a call to kbase_pm_check_transitions_nolock from a
 217  * certin caller */
 218 #define KBASE_TIMELINE_PM_CHECKTRANS(kbdev, trace_code)                      \
 219         do {                                                                 \
 220                 struct timespec ts;                                          \
 221                 getrawmonotonic(&ts);                                        \
 222                 trace_mali_timeline_pm_checktrans(ts.tv_sec, ts.tv_nsec,     \
 223                                 trace_code, 1);                              \
 224         } while (0)
 225
 226 /* Trace number of contexts active */
 227 #define KBASE_TIMELINE_CONTEXT_ACTIVE(kbdev, count)                          \
 228         do {                                                                 \
 229                 struct timespec ts;                                          \
 230                 getrawmonotonic(&ts);                                        \
 231                 trace_mali_timeline_context_active(ts.tv_sec, ts.tv_nsec,    \
 232                                 count);                                      \
 233         } while (0)
 234
 235
 236 /* NOTE: kbase_timeline_pm_cores_func() is in mali_kbase_pm_policy.c */
 237
 238 /**
 239  * Trace that an atom is starting on a job slot
 240  *
 241  * The caller must be holding kbasep_js_device_data::runpool_irq::lock
 242  */
 243 void kbase_timeline_job_slot_submit(struct kbase_device *kbdev, struct kbase_context *kctx,
 244                 struct kbase_jd_atom *katom, int js);
 245
 246 /**
 247  * Trace that an atom has done on a job slot
 248  *
 249  * 'Done' in this sense can occur either because:
 250  * - the atom in JS_HEAD finished
 251  * - the atom in JS_NEXT was evicted
 252  *
 253  * Whether the atom finished or was evicted is passed in @a done_code
 254  *
 255  * It is assumed that the atom has already been removed from the submit slot,
 256  * with either:
 257  * - kbasep_jm_dequeue_submit_slot()
 258  * - kbasep_jm_dequeue_tail_submit_slot()
 259  *
 260  * The caller must be holding kbasep_js_device_data::runpool_irq::lock
 261  */
 262 void kbase_timeline_job_slot_done(struct kbase_device *kbdev, struct kbase_context *kctx,
 263                 struct kbase_jd_atom *katom, int js,
 264                 kbasep_js_atom_done_code done_code);
 265
 266
 267 /** Trace a pm event starting */
 268 void kbase_timeline_pm_send_event(struct kbase_device *kbdev,
 269                 enum kbase_timeline_pm_event event_sent);
 270
 271 /** Trace a pm event finishing */
 272 void kbase_timeline_pm_check_handle_event(struct kbase_device *kbdev, enum kbase_timeline_pm_event event);
 273
 274 /** Check whether a pm event was present, and if so trace finishing it */
 275 void kbase_timeline_pm_handle_event(struct kbase_device *kbdev, enum kbase_timeline_pm_event event);
 276
 277 /** Trace L2 power-up start */
 278 void kbase_timeline_pm_l2_transition_start(struct kbase_device *kbdev);
 279
 280 /** Trace L2 power-up done */
 281 void kbase_timeline_pm_l2_transition_done(struct kbase_device *kbdev);
 282
 283 #else
 284
 285 #define KBASE_TIMELINE_ATOMS_IN_FLIGHT(kctx, count) CSTD_NOP()
 286
 287 #define KBASE_TIMELINE_ATOM_READY(kctx, atom_id) CSTD_NOP()
 288
 289 #define KBASE_TIMELINE_ATOMS_SUBMITTED(kctx, js, count) CSTD_NOP()
 290
 291 #define KBASE_TIMELINE_JOB_START_NEXT(kctx, js, count) CSTD_NOP()
 292
 293 #define KBASE_TIMELINE_JOB_START_HEAD(kctx, js, count) CSTD_NOP()
 294
 295 #define KBASE_TIMELINE_TRY_SOFT_STOP(kctx, js, count) CSTD_NOP()
 296
 297 #define KBASE_TIMELINE_GPU_POWER(kbdev, active) CSTD_NOP()
 298
 299 #define KBASE_TIMELINE_POWER_TILER(kbdev, bitmap) CSTD_NOP()
 300
 301 #define KBASE_TIMELINE_POWER_SHADER(kbdev, bitmap) CSTD_NOP()
 302
 303 #define KBASE_TIMELINE_POWER_L2(kbdev, active) CSTD_NOP()
 304
 305 #define KBASE_TIMELINE_POWERING_L2(kbdev) CSTD_NOP()
 306
 307 #define KBASE_TIMELINE_POWERED_L2(kbdev)  CSTD_NOP()
 308
 309 #define KBASE_TIMELINE_PM_SEND_EVENT(kbdev, event_type, pm_event_id) CSTD_NOP()
 310
 311 #define KBASE_TIMELINE_PM_HANDLE_EVENT(kbdev, event_type, pm_event_id) CSTD_NOP()
 312
 313 #define KBASE_TIMELINE_JOB_START(kctx, js, _consumerof_atom_number) CSTD_NOP()
 314
 315 #define KBASE_TIMELINE_JOB_STOP(kctx, js, _producerof_atom_number_completed) CSTD_NOP()
 316
 317 #define KBASE_TIMELINE_PM_CHECKTRANS(kbdev, trace_code) CSTD_NOP()
 318
 319 #define KBASE_TIMELINE_CONTEXT_ACTIVE(kbdev, count) CSTD_NOP()
 320
 321 static inline void kbase_timeline_job_slot_submit(struct kbase_device *kbdev, struct kbase_context *kctx,
 322                 struct kbase_jd_atom *katom, int js)
 323 {
 324         lockdep_assert_held(&kbdev->js_data.runpool_irq.lock);
 325 }
 326
 327 static inline void kbase_timeline_job_slot_done(struct kbase_device *kbdev, struct kbase_context *kctx,
 328                 struct kbase_jd_atom *katom, int js,
 329                 kbasep_js_atom_done_code done_code)
 330 {
 331         lockdep_assert_held(&kbdev->js_data.runpool_irq.lock);
 332 }
 333
 334 static inline void kbase_timeline_pm_send_event(struct kbase_device *kbdev, enum kbase_timeline_pm_event event_sent)
 335 {
 336 }
 337
 338 static inline void kbase_timeline_pm_check_handle_event(struct kbase_device *kbdev, enum kbase_timeline_pm_event event)
 339 {
 340 }
 341
 342 static inline void kbase_timeline_pm_handle_event(struct kbase_device *kbdev, enum kbase_timeline_pm_event event)
 343 {
 344 }
 345
 346 static inline void kbase_timeline_pm_l2_transition_start(struct kbase_device *kbdev)
 347 {
 348 }
 349
 350 static inline void kbase_timeline_pm_l2_transition_done(struct kbase_device *kbdev)
 351 {
 352 }
 353 #endif                          /* CONFIG_MALI_TRACE_TIMELINE */
 354
 355 #endif                          /* _KBASE_TRACE_TIMELINE_H */
 356