src/gallium/drivers/swr/rasterizer/common/rdtsc_buckets_shared.h

   1 /****************************************************************************
   2  * Copyright (C) 2014-2015 Intel Corporation.   All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice (including the next
  12  * paragraph) shall be included in all copies or substantial portions of the
  13  * Software.
  14  *
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  19  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
  20  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
  21  * IN THE SOFTWARE.
  22  *
  23  * @file rdtsc_buckets.h
  24  *
  25  * @brief declaration for rdtsc buckets.
  26  *
  27  * Notes:
  28  *
  29  ******************************************************************************/
  30 #pragma once
  31
  32 #include <vector>
  33 #include <cassert>
  34
  35 struct BUCKET
  36 {
  37     uint32_t id{0};
  38     uint64_t start{0};
  39     uint64_t elapsed{0};
  40     uint32_t count{0};
  41
  42     BUCKET*             pParent{nullptr};
  43     std::vector<BUCKET> children;
  44 };
  45
  46 struct BUCKET_DESC
  47 {
  48     // name of bucket, used in reports
  49     std::string name;
  50
  51     // description of bucket, used in threadviz
  52     std::string description;
  53
  54     // enable for threadviz dumping
  55     bool enableThreadViz;
  56
  57     // threadviz color of bucket, in RGBA8_UNORM format
  58     uint32_t color;
  59 };
  60
  61
  62 struct BUCKET_THREAD
  63 {
  64     // name of thread, used in reports
  65     std::string name;
  66
  67     // id for this thread, assigned by the thread manager
  68     uint32_t id{0};
  69
  70     // root of the bucket hierarchy for this thread
  71     BUCKET root;
  72
  73     // currently executing bucket somewhere in the hierarchy
  74     BUCKET* pCurrent{nullptr};
  75
  76     // currently executing hierarchy level
  77     uint32_t level{0};
  78
  79     // threadviz file object
  80     FILE* vizFile{nullptr};
  81
  82
  83     BUCKET_THREAD() {}
  84     BUCKET_THREAD(const BUCKET_THREAD& that)
  85     {
  86         name     = that.name;
  87         id       = that.id;
  88         root     = that.root;
  89         pCurrent = &root;
  90         vizFile  = that.vizFile;
  91     }
  92 };
  93
  94 enum VIZ_TYPE
  95 {
  96     VIZ_START = 0,
  97     VIZ_STOP  = 1,
  98     VIZ_DATA  = 2
  99 };
 100
 101 struct VIZ_START_DATA
 102 {
 103     uint8_t  type;
 104     uint32_t bucketId;
 105     uint64_t timestamp;
 106 };
 107
 108 struct VIZ_STOP_DATA
 109 {
 110     uint8_t  type;
 111     uint64_t timestamp;
 112 };
 113
 114 inline void Serialize(FILE* f, const VIZ_START_DATA& data)
 115 {
 116     fwrite(&data, sizeof(VIZ_START_DATA), 1, f);
 117 }
 118
 119 inline void Deserialize(FILE* f, VIZ_START_DATA& data)
 120 {
 121     fread(&data, sizeof(VIZ_START_DATA), 1, f);
 122     assert(data.type == VIZ_START);
 123 }
 124
 125 inline void Serialize(FILE* f, const VIZ_STOP_DATA& data)
 126 {
 127     fwrite(&data, sizeof(VIZ_STOP_DATA), 1, f);
 128 }
 129
 130 inline void Deserialize(FILE* f, VIZ_STOP_DATA& data)
 131 {
 132     fread(&data, sizeof(VIZ_STOP_DATA), 1, f);
 133     assert(data.type == VIZ_STOP);
 134 }
 135
 136 inline void Serialize(FILE* f, const std::string& string)
 137 {
 138     assert(string.size() <= 256);
 139
 140     uint8_t length = (uint8_t)string.size();
 141     fwrite(&length, sizeof(length), 1, f);
 142     fwrite(string.c_str(), string.size(), 1, f);
 143 }
 144
 145 inline void Deserialize(FILE* f, std::string& string)
 146 {
 147     char    cstr[256];
 148     uint8_t length;
 149     fread(&length, sizeof(length), 1, f);
 150     fread(cstr, length, 1, f);
 151     cstr[length] = 0;
 152     string.assign(cstr);
 153 }
 154
 155 inline void Serialize(FILE* f, const BUCKET_DESC& desc)
 156 {
 157     Serialize(f, desc.name);
 158     Serialize(f, desc.description);
 159     fwrite(&desc.enableThreadViz, sizeof(desc.enableThreadViz), 1, f);
 160     fwrite(&desc.color, sizeof(desc.color), 1, f);
 161 }
 162
 163 inline void Deserialize(FILE* f, BUCKET_DESC& desc)
 164 {
 165     Deserialize(f, desc.name);
 166     Deserialize(f, desc.description);
 167     fread(&desc.enableThreadViz, sizeof(desc.enableThreadViz), 1, f);
 168     fread(&desc.color, sizeof(desc.color), 1, f);
 169 }