SkSL::DebugTracePriv Class Reference

#include <SkSLDebugTracePriv.h>

Inheritance diagram for SkSL::DebugTracePriv:

Public Member Functions
void	setTraceCoord (const SkIPoint &coord)
void	setSource (const std::string &source)
bool	readTrace (SkStream *r)
void	writeTrace (SkWStream *w) const override
void	dump (SkWStream *o) const override
std::string	getSlotComponentSuffix (int slotIndex) const
std::string	getSlotValue (int slotIndex, int32_t value) const
double	interpretValueBits (int slotIndex, int32_t valueBits) const
std::string	slotValueToString (int slotIndex, double value) const
Public Member Functions inherited from SkRefCntBase
	SkRefCntBase ()
virtual	~SkRefCntBase ()
bool	unique () const
void	ref () const
void	unref () const

Public Attributes
SkIPoint	fTraceCoord = {}
std::vector< SlotDebugInfo >	fUniformInfo
std::vector< SlotDebugInfo >	fSlotInfo
std::vector< FunctionDebugInfo >	fFuncInfo
std::vector< TraceInfo >	fTraceInfo
std::vector< std::string >	fSource
std::unique_ptr< SkSL::TraceHook >	fTraceHook

Detailed Description

Definition at line 62 of file SkSLDebugTracePriv.h.

Member Function Documentation

dump()

void SkSL::DebugTracePriv::dump ( SkWStream *  o ) const

overridevirtual

Generates a human-readable dump of the debug trace.

Implements SkSL::DebugTrace.

Definition at line 103 of file SkSLDebugTracePriv.cpp.

                                            {
    for (size_t index = 0; index < fSlotInfo.size(); ++index) {
        const SlotDebugInfo& info = fSlotInfo[index];
 
        o->writeText("$");
        o->writeDecAsText(index);
        o->writeText(" = ");
        o->writeText(info.name.c_str());
        o->writeText(" (");
        switch (info.numberKind) {
            case Type::NumberKind::kFloat:      o->writeText("float"); break;
            case Type::NumberKind::kSigned:     o->writeText("int"); break;
            case Type::NumberKind::kUnsigned:   o->writeText("uint"); break;
            case Type::NumberKind::kBoolean:    o->writeText("bool"); break;
            case Type::NumberKind::kNonnumeric: o->writeText("???"); break;
        }
        if (info.rows * info.columns > 1) {
            o->writeDecAsText(info.columns);
            if (info.rows != 1) {
                o->writeText("x");
                o->writeDecAsText(info.rows);
            }
            o->writeText(" : ");
            o->writeText("slot ");
            o->writeDecAsText(info.componentIndex + 1);
            o->writeText("/");
            o->writeDecAsText(info.rows * info.columns);
        }
        o->writeText(", L");
        o->writeDecAsText(info.line);
        o->writeText(")");
        o->newline();
    }
 
    for (size_t index = 0; index < fFuncInfo.size(); ++index) {
        const FunctionDebugInfo& info = fFuncInfo[index];
 
        o->writeText("F");
        o->writeDecAsText(index);
        o->writeText(" = ");
        o->writeText(info.name.c_str());
        o->newline();
    }
 
    o->newline();
 
    if (!fTraceInfo.empty()) {
        std::string indent = "";
        for (const SkSL::TraceInfo& traceInfo : fTraceInfo) {
            int data0 = traceInfo.data[0];
            int data1 = traceInfo.data[1];
            switch (traceInfo.op) {
                case SkSL::TraceInfo::Op::kLine:
                    o->writeText(indent.c_str());
                    o->writeText("line ");
                    o->writeDecAsText(data0);
                    break;
 
                case SkSL::TraceInfo::Op::kVar: {
                    const SlotDebugInfo& slot = fSlotInfo[data0];
                    o->writeText(indent.c_str());
                    o->writeText(slot.name.c_str());
                    o->writeText(this->getSlotComponentSuffix(data0).c_str());
                    o->writeText(" = ");
                    o->writeText(this->getSlotValue(data0, data1).c_str());
                    break;
                }
                case SkSL::TraceInfo::Op::kEnter:
                    o->writeText(indent.c_str());
                    o->writeText("enter ");
                    o->writeText(fFuncInfo[data0].name.c_str());
                    indent += "  ";
                    break;
 
                case SkSL::TraceInfo::Op::kExit:
                    indent.resize(indent.size() - 2);
                    o->writeText(indent.c_str());
                    o->writeText("exit ");
                    o->writeText(fFuncInfo[data0].name.c_str());
                    break;
 
                case SkSL::TraceInfo::Op::kScope:
                    for (int delta = data0; delta < 0; ++delta) {
                        indent.pop_back();
                    }
                    o->writeText(indent.c_str());
                    o->writeText("scope ");
                    o->writeText((data0 >= 0) ? "+" : "");
                    o->writeDecAsText(data0);
                    for (int delta = data0; delta > 0; --delta) {
                        indent.push_back(' ');
                    }
                    break;
            }
            o->newline();
        }
    }
}

getSlotComponentSuffix()

std::string SkSL::DebugTracePriv::getSlotComponentSuffix

(

int

slotIndex

)

const

Returns a slot's component as a variable-name suffix, e.g. ".x" or "[2][2]".

Definition at line 29 of file SkSLDebugTracePriv.cpp.

                                                                    {
    const SkSL::SlotDebugInfo& slot = fSlotInfo[slotIndex];
 
    if (slot.rows > 1) {
        return "["  + std::to_string(slot.componentIndex / slot.rows) +
               "][" + std::to_string(slot.componentIndex % slot.rows) +
               "]";
    }
    if (slot.columns > 1) {
        switch (slot.componentIndex) {
            case 0:  return ".x";
            case 1:  return ".y";
            case 2:  return ".z";
            case 3:  return ".w";
            default: return "[???]";
        }
    }
    return {};
}

getSlotValue()

std::string SkSL::DebugTracePriv::getSlotValue	(	int	slotIndex,
		int32_t	value
	)		const

Bit-casts a slot's value, then converts to text, e.g. "3.14" or "true" or "12345".

Definition at line 86 of file SkSLDebugTracePriv.cpp.

                                                                             {
    return this->slotValueToString(slotIndex, this->interpretValueBits(slotIndex, valueBits));
}

interpretValueBits()

double SkSL::DebugTracePriv::interpretValueBits	(	int	slotIndex,
		int32_t	valueBits
	)		const

Bit-casts a value for a given slot into a double, honoring the slot's NumberKind.

Definition at line 49 of file SkSLDebugTracePriv.cpp.

                                                                                {
    SkASSERT(slotIndex >= 0);
    SkASSERT((size_t)slotIndex < fSlotInfo.size());
    switch (fSlotInfo[slotIndex].numberKind) {
        case SkSL::Type::NumberKind::kUnsigned: {
            uint32_t uintValue;
            static_assert(sizeof(uintValue) == sizeof(valueBits));
            memcpy(&uintValue, &valueBits, sizeof(uintValue));
            return uintValue;
        }
        case SkSL::Type::NumberKind::kFloat: {
            float floatValue;
            static_assert(sizeof(floatValue) == sizeof(valueBits));
            memcpy(&floatValue, &valueBits, sizeof(floatValue));
            return floatValue;
        }
        default: {
            return valueBits;
        }
    }
}

readTrace()

bool SkSL::DebugTracePriv::readTrace

(

SkStream *

r

)

Serializes a debug trace to JSON which can be parsed by our debugger.

Definition at line 270 of file SkSLDebugTracePriv.cpp.

                                          {
    sk_sp<SkData> data = SkCopyStreamToData(r);
    skjson::DOM json(reinterpret_cast<const char*>(data->bytes()), data->size());
    const skjson::ObjectValue* root = json.root();
    if (!root) {
        return false;
    }
 
    const skjson::StringValue* version = (*root)["version"];
    if (!version || version->str() != kTraceVersion) {
        return false;
    }
 
    const skjson::ArrayValue* source = (*root)["source"];
    if (!source) {
        return false;
    }
 
    fSource.clear();
    for (const skjson::StringValue* line : *source) {
        if (!line) {
            return false;
        }
        fSource.push_back(line->begin());
    }
 
    const skjson::ArrayValue* slots = (*root)["slots"];
    if (!slots) {
        return false;
    }
 
    fSlotInfo.clear();
    for (const skjson::ObjectValue* element : *slots) {
        if (!element) {
            return false;
        }
 
        // Grow the slot array to hold this element.
        fSlotInfo.push_back({});
        SlotDebugInfo& info = fSlotInfo.back();
 
        // Populate the SlotInfo with our JSON data.
        const skjson::StringValue* name     = (*element)["name"];
        const skjson::NumberValue* columns  = (*element)["columns"];
        const skjson::NumberValue* rows     = (*element)["rows"];
        const skjson::NumberValue* index    = (*element)["index"];
        const skjson::NumberValue* groupIdx = (*element)["groupIdx"];
        const skjson::NumberValue* kind     = (*element)["kind"];
        const skjson::NumberValue* line     = (*element)["line"];
        const skjson::NumberValue* retval   = (*element)["retval"];
        if (!name || !columns || !rows || !index || !kind || !line) {
            return false;
        }
 
        info.name = name->begin();
        info.columns = **columns;
        info.rows = **rows;
        info.componentIndex = **index;
        info.groupIndex = groupIdx ? **groupIdx : info.componentIndex;
        info.numberKind = (SkSL::Type::NumberKind)(int)**kind;
        info.line = **line;
        info.fnReturnValue = retval ? **retval : -1;
    }
 
    const skjson::ArrayValue* functions = (*root)["functions"];
    if (!functions) {
        return false;
    }
 
    fFuncInfo.clear();
    for (const skjson::ObjectValue* element : *functions) {
        if (!element) {
            return false;
        }
 
        // Grow the function array to hold this element.
        fFuncInfo.push_back({});
        FunctionDebugInfo& info = fFuncInfo.back();
 
        // Populate the FunctionInfo with our JSON data.
        const skjson::StringValue* name = (*element)["name"];
        if (!name) {
            return false;
        }
 
        info.name = name->begin();
    }
 
    const skjson::ArrayValue* trace = (*root)["trace"];
    if (!trace) {
        return false;
    }
 
    fTraceInfo.clear();
    fTraceInfo.reserve(trace->size());
    for (const skjson::ArrayValue* element : *trace) {
        fTraceInfo.push_back(TraceInfo{});
        TraceInfo& info = fTraceInfo.back();
 
        if (!element || element->size() < 1 || element->size() > (1 + std::size(info.data))) {
            return false;
        }
        const skjson::NumberValue* opVal = (*element)[0];
        if (!opVal) {
            return false;
        }
        info.op = (TraceInfo::Op)(int)**opVal;
        for (size_t elemIdx = 1; elemIdx < element->size(); ++elemIdx) {
            const skjson::NumberValue* dataVal = (*element)[elemIdx];
            if (!dataVal) {
                return false;
            }
            info.data[elemIdx - 1] = **dataVal;
        }
    }
 
    return true;
}

setSource()

void SkSL::DebugTracePriv::setSource

(

const std::string &

source

)

Attaches the SkSL source to be debugged.

Definition at line 94 of file SkSLDebugTracePriv.cpp.

                                                      {
    fSource.clear();
    std::stringstream stream{source};
    while (stream.good()) {
        fSource.push_back({});
        std::getline(stream, fSource.back(), '\n');
    }
}

setTraceCoord()

void SkSL::DebugTracePriv::setTraceCoord

(

const SkIPoint &

coord

)

Sets the device-coordinate pixel to trace. If it's not set, the point at (0, 0) will be used.

Definition at line 90 of file SkSLDebugTracePriv.cpp.

                                                        {
    fTraceCoord = coord;
}

slotValueToString()

std::string SkSL::DebugTracePriv::slotValueToString	(	int	slotIndex,
		double	value
	)		const

Converts a numeric value into text, based on the slot's NumberKind.

Definition at line 71 of file SkSLDebugTracePriv.cpp.

                                                                             {
    SkASSERT(slotIndex >= 0);
    SkASSERT((size_t)slotIndex < fSlotInfo.size());
    switch (fSlotInfo[slotIndex].numberKind) {
        case SkSL::Type::NumberKind::kBoolean: {
            return value ? "true" : "false";
        }
        default: {
            char buffer[32];
            snprintf(buffer, std::size(buffer), "%.8g", value);
            return buffer;
        }
    }
}

writeTrace()

void SkSL::DebugTracePriv::writeTrace ( SkWStream *  w ) const

overridevirtual

Serializes a debug trace to JSON which can be parsed by our debugger.

Implements SkSL::DebugTrace.

Definition at line 202 of file SkSLDebugTracePriv.cpp.

                                                  {
    SkJSONWriter json(w);
 
    json.beginObject(); // root
    json.appendNString("version", kTraceVersion);
    json.beginArray("source");
 
    for (const std::string& line : fSource) {
        json.appendString(line);
    }
 
    json.endArray(); // code
    json.beginArray("slots");
 
    for (size_t index = 0; index < fSlotInfo.size(); ++index) {
        const SlotDebugInfo& info = fSlotInfo[index];
 
        json.beginObject();
        json.appendString("name", info.name.data(), info.name.size());
        json.appendS32("columns", info.columns);
        json.appendS32("rows", info.rows);
        json.appendS32("index", info.componentIndex);
        if (info.groupIndex != info.componentIndex) {
            json.appendS32("groupIdx", info.groupIndex);
        }
        json.appendS32("kind", (int)info.numberKind);
        json.appendS32("line", info.line);
        if (info.fnReturnValue >= 0) {
            json.appendS32("retval", info.fnReturnValue);
        }
        json.endObject();
    }
 
    json.endArray(); // slots
    json.beginArray("functions");
 
    for (size_t index = 0; index < fFuncInfo.size(); ++index) {
        const FunctionDebugInfo& info = fFuncInfo[index];
 
        json.beginObject();
        json.appendString("name", info.name);
        json.endObject();
    }
 
    json.endArray(); // functions
    json.beginArray("trace");
 
    for (size_t index = 0; index < fTraceInfo.size(); ++index) {
        const TraceInfo& trace = fTraceInfo[index];
        json.beginArray();
        json.appendS32((int)trace.op);
 
        // Skip trailing zeros in the data (since most ops only use one value).
        int lastDataIdx = std::size(trace.data) - 1;
        while (lastDataIdx >= 0 && !trace.data[lastDataIdx]) {
            --lastDataIdx;
        }
        for (int dataIdx = 0; dataIdx <= lastDataIdx; ++dataIdx) {
            json.appendS32(trace.data[dataIdx]);
        }
        json.endArray();
    }
 
    json.endArray(); // trace
    json.endObject(); // root
    json.flush();
}

Member Data Documentation

fFuncInfo

std::vector<FunctionDebugInfo> SkSL::DebugTracePriv::fFuncInfo

Definition at line 99 of file SkSLDebugTracePriv.h.

fSlotInfo

std::vector<SlotDebugInfo> SkSL::DebugTracePriv::fSlotInfo

A 1:1 mapping of slot numbers to debug information.

Definition at line 98 of file SkSLDebugTracePriv.h.

fSource

std::vector<std::string> SkSL::DebugTracePriv::fSource

The SkSL code, split line-by-line.

Definition at line 105 of file SkSLDebugTracePriv.h.

fTraceCoord

SkIPoint SkSL::DebugTracePriv::fTraceCoord = {}

The device-coordinate pixel to trace (controlled by setTraceCoord)

Definition at line 92 of file SkSLDebugTracePriv.h.

{};

fTraceHook

std::unique_ptr<SkSL::TraceHook> SkSL::DebugTracePriv::fTraceHook

A trace hook which populates fTraceInfo during shader evaluation. This will be created automatically during code generation.

Definition at line 111 of file SkSLDebugTracePriv.h.

fTraceInfo

std::vector<TraceInfo> SkSL::DebugTracePriv::fTraceInfo

The SkSL debug trace.

Definition at line 102 of file SkSLDebugTracePriv.h.

fUniformInfo

std::vector<SlotDebugInfo> SkSL::DebugTracePriv::fUniformInfo

SkRP stores uniform slot info in fUniformInfo. (In SkVM, they were mixed into fSlotInfo.)

Definition at line 95 of file SkSLDebugTracePriv.h.

---

The documentation for this class was generated from the following files:

• third_party/skia/src/sksl/tracing/SkSLDebugTracePriv.h
• third_party/skia/src/sksl/tracing/SkSLDebugTracePriv.cpp