KonstantinSeurer
/
mesa
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

nv50/ir: Add nv50_ir_prog_info_out serialize and deserialize 

Adds functions for serializing and deserializing
nv50_ir_prog_info_out structure, which are needed for shader caching.

Signed-off-by: Mark Menzynski <mmenzyns@redhat.com>
Reviewed-by: Karol Herbst <kherbst@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/4264>
This commit is contained in:
Mark Menzynski 2020-02-17 18:02:45 +01:00 committed by Marge Bot
parent 5ecc06ef20
commit f20a210dc8
8 changed files with 311 additions and 31 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/gallium/drivers/nouveau/codegen/nv50_ir_driver.h
View File

@ -25,6 +25,7 @@
#include "pipe/p_shader_tokens.h"
#include "util/blob.h"
#include "tgsi/tgsi_util.h"
#include "tgsi/tgsi_parse.h"
#include "tgsi/tgsi_scan.h"
@ -229,6 +230,54 @@ nv50_ir_apply_fixups(void *fixupData, uint32_t *code,
extern void nv50_ir_get_target_library(uint32_t chipset,
const uint32_t **code, uint32_t *size);
#ifdef __cplusplus
namespace nv50_ir
{
class FixupEntry;
class FixupData;
void
gk110_interpApply(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
gm107_interpApply(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
nv50_interpApply(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
nvc0_interpApply(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
gv100_interpApply(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
gk110_selpFlip(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
gm107_selpFlip(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
nvc0_selpFlip(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
void
gv100_selpFlip(const nv50_ir::FixupEntry *entry, uint32_t *code,
const nv50_ir::FixupData& data);
}
#endif
/* Serialize a nv50_ir_prog_info_out structure and save it into blob */
extern bool MUST_CHECK
nv50_ir_prog_info_out_serialize(struct blob *, struct nv50_ir_prog_info_out *);
/* Deserialize from data and save into a nv50_ir_prog_info_out structure
* using a pointer. Size is a total size of the serialized data.
* Offset points to where info_out in data is located. */
extern bool MUST_CHECK
nv50_ir_prog_info_out_deserialize(void *data, size_t size, size_t offset,
struct nv50_ir_prog_info_out *);
#ifdef __cplusplus
}
#endif

14
src/gallium/drivers/nouveau/codegen/nv50_ir_emit_gk110.cpp
View File

@ -1209,8 +1209,8 @@ CodeEmitterGK110::emitSLCT(const CmpInstruction *i)
}
}
static void
selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
gk110_selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int loc = entry->loc;
if (data.force_persample_interp)
@ -1227,7 +1227,7 @@ void CodeEmitterGK110::emitSELP(const Instruction *i)
code[1] |= 1 << 13;
if (i->subOp == 1) {
addInterp(0, 0, selpFlip);
addInterp(0, 0, gk110_selpFlip);
}
}
@ -2042,8 +2042,8 @@ CodeEmitterGK110::emitInterpMode(const Instruction *i)
code[1] |= (i->ipa & 0xc) << (19 - 2);
}
static void
interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
gk110_interpApply(const struct FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int ipa = entry->ipa;
int reg = entry->reg;
@ -2078,10 +2078,10 @@ CodeEmitterGK110::emitINTERP(const Instruction *i)
if (i->op == OP_PINTERP) {
srcId(i->src(1), 23);
addInterp(i->ipa, SDATA(i->src(1)).id, interpApply);
addInterp(i->ipa, SDATA(i->src(1)).id, gk110_interpApply);
} else {
code[0] |= 0xff << 23;
addInterp(i->ipa, 0xff, interpApply);
addInterp(i->ipa, 0xff, gk110_interpApply);
}
srcId(i->src(0).getIndirect(0), 10);

14
src/gallium/drivers/nouveau/codegen/nv50_ir_emit_gm107.cpp
View File

@ -949,8 +949,8 @@ CodeEmitterGM107::emitI2I()
emitGPR (0x00, insn->def(0));
}
static void
selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
gm107_selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int loc = entry->loc;
if (data.force_persample_interp)
@ -986,7 +986,7 @@ CodeEmitterGM107::emitSEL()
emitGPR (0x00, insn->def(0));
if (insn->subOp == 1) {
addInterp(0, 0, selpFlip);
addInterp(0, 0, gm107_selpFlip);
}
}
@ -2556,8 +2556,8 @@ CodeEmitterGM107::emitAL2P()
emitGPR (0x00, insn->def(0));
}
static void
interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
gm107_interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int ipa = entry->ipa;
int reg = entry->reg;
@ -2617,12 +2617,12 @@ CodeEmitterGM107::emitIPA()
emitGPR(0x14, insn->src(1));
if (insn->getSampleMode() == NV50_IR_INTERP_OFFSET)
emitGPR(0x27, insn->src(2));
addInterp(insn->ipa, insn->getSrc(1)->reg.data.id, interpApply);
addInterp(insn->ipa, insn->getSrc(1)->reg.data.id, gm107_interpApply);
} else {
if (insn->getSampleMode() == NV50_IR_INTERP_OFFSET)
emitGPR(0x27, insn->src(1));
emitGPR(0x14);
addInterp(insn->ipa, 0xff, interpApply);
addInterp(insn->ipa, 0xff, gm107_interpApply);
}
if (insn->getSampleMode() != NV50_IR_INTERP_OFFSET)

14
src/gallium/drivers/nouveau/codegen/nv50_ir_emit_gv100.cpp
View File

@ -350,8 +350,8 @@ CodeEmitterGV100::emitS2R()
emitGPR (16, insn->def(0));
}
static void
selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
gv100_selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int loc = entry->loc;
if (data.force_persample_interp)
@ -367,7 +367,7 @@ CodeEmitterGV100::emitSEL()
emitNOT (90, insn->src(2));
emitPRED (87, insn->src(2));
if (insn->subOp == 1)
addInterp(0, 0, selpFlip);
addInterp(0, 0, gv100_selpFlip);
}
void
@ -910,8 +910,8 @@ CodeEmitterGV100::emitATOMS()
emitGPR (16, insn->def(0));
}
static void
interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
gv100_interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int ipa = entry->ipa;
int loc = entry->loc;
@ -971,10 +971,10 @@ CodeEmitterGV100::emitIPA()
if (insn->getSampleMode() != NV50_IR_INTERP_OFFSET) {
emitGPR (32);
addInterp(insn->ipa, 0xff, interpApply);
addInterp(insn->ipa, 0xff, gv100_interpApply);
} else {
emitGPR (32, insn->src(1));
addInterp(insn->ipa, insn->getSrc(1)->reg.data.id, interpApply);
addInterp(insn->ipa, insn->getSrc(1)->reg.data.id, gv100_interpApply);
}
assert(!insn->src(0).isIndirect(0));

6
src/gallium/drivers/nouveau/codegen/nv50_ir_emit_nv50.cpp
View File

@ -881,8 +881,8 @@ CodeEmitterNV50::emitPFETCH(const Instruction *i)
emitFlagsRd(i);
}
static void
interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
nv50_interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int ipa = entry->ipa;
int encSize = entry->reg;
@ -934,7 +934,7 @@ CodeEmitterNV50::emitINTERP(const Instruction *i)
emitFlagsRd(i);
}
addInterp(i->ipa, i->encSize, interpApply);
addInterp(i->ipa, i->encSize, nv50_interpApply);
}
void

14
src/gallium/drivers/nouveau/codegen/nv50_ir_emit_nvc0.cpp
View File

@ -1255,8 +1255,8 @@ CodeEmitterNVC0::emitSLCT(const CmpInstruction *i)
code[0] |= 1 << 5;
}
static void
selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
nvc0_selpFlip(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int loc = entry->loc;
if (data.force_persample_interp)
@ -1273,7 +1273,7 @@ void CodeEmitterNVC0::emitSELP(const Instruction *i)
code[1] |= 1 << 20;
if (i->subOp == 1) {
addInterp(0, 0, selpFlip);
addInterp(0, 0, nvc0_selpFlip);
}
}
@ -1726,8 +1726,8 @@ CodeEmitterNVC0::emitInterpMode(const Instruction *i)
}
}
static void
interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
void
nvc0_interpApply(const FixupEntry *entry, uint32_t *code, const FixupData& data)
{
int ipa = entry->ipa;
int reg = entry->reg;
@ -1762,10 +1762,10 @@ CodeEmitterNVC0::emitINTERP(const Instruction *i)
if (i->op == OP_PINTERP) {
srcId(i->src(1), 26);
addInterp(i->ipa, SDATA(i->src(1)).id, interpApply);
addInterp(i->ipa, SDATA(i->src(1)).id, nvc0_interpApply);
} else {
code[0] |= 0x3f << 26;
addInterp(i->ipa, 0x3f, interpApply);
addInterp(i->ipa, 0x3f, nvc0_interpApply);
}
srcId(i->src(0).getIndirect(0), 20);

230
src/gallium/drivers/nouveau/codegen/nv50_ir_serialize.cpp Normal file
View File

@ -0,0 +1,230 @@
#include "util/blob.h"
#include "codegen/nv50_ir_driver.h"
#include "codegen/nv50_ir.h"
#include "codegen/nv50_ir_target.h"
#include "nv50_ir_driver.h"
#include "tgsi/tgsi_parse.h"
#include "compiler/nir/nir_serialize.h"
enum FixupApplyFunc {
APPLY_NV50,
APPLY_NVC0,
APPLY_GK110,
APPLY_GM107,
APPLY_GV100,
FLIP_NVC0,
FLIP_GK110,
FLIP_GM107,
FLIP_GV100,
};
extern bool
nv50_ir_prog_info_out_serialize(struct blob *blob,
struct nv50_ir_prog_info_out *info_out)
{
blob_write_uint16(blob, info_out->target);
blob_write_uint8(blob, info_out->type);
blob_write_uint8(blob, info_out->numPatchConstants);
blob_write_uint16(blob, info_out->bin.maxGPR);
blob_write_uint32(blob, info_out->bin.tlsSpace);
blob_write_uint32(blob, info_out->bin.smemSize);
blob_write_uint32(blob, info_out->bin.codeSize);
blob_write_bytes(blob, info_out->bin.code, info_out->bin.codeSize);
blob_write_uint32(blob, info_out->bin.instructions);
if (!info_out->bin.relocData) {
blob_write_uint32(blob, 0); // reloc count 0
} else {
nv50_ir::RelocInfo *reloc = (nv50_ir::RelocInfo *)info_out->bin.relocData;
blob_write_uint32(blob, reloc->count);
blob_write_uint32(blob, reloc->codePos);
blob_write_uint32(blob, reloc->libPos);
blob_write_uint32(blob, reloc->dataPos);
blob_write_bytes(blob, reloc->entry, sizeof(*reloc->entry) * reloc->count);
}
if (!info_out->bin.fixupData) {
blob_write_uint32(blob, 0); // fixup count 0
} else {
nv50_ir::FixupInfo *fixup = (nv50_ir::FixupInfo *)info_out->bin.fixupData;
blob_write_uint32(blob, fixup->count);
/* Going through each entry */
for (uint32_t i = 0; i < fixup->count; i++) {
blob_write_uint32(blob, fixup->entry[i].val);
assert(fixup->entry[i].apply);
/* Compare function pointers, for when at serializing
* to know which function to apply */
if (fixup->entry[i].apply == nv50_ir::nv50_interpApply)
blob_write_uint8(blob, APPLY_NV50);
else if (fixup->entry[i].apply == nv50_ir::nvc0_interpApply)
blob_write_uint8(blob, APPLY_NVC0);
else if (fixup->entry[i].apply == nv50_ir::gk110_interpApply)
blob_write_uint8(blob, APPLY_GK110);
else if (fixup->entry[i].apply == nv50_ir::gm107_interpApply)
blob_write_uint8(blob, APPLY_GM107);
else if (fixup->entry[i].apply == nv50_ir::gv100_interpApply)
blob_write_uint8(blob, APPLY_GV100);
else if (fixup->entry[i].apply == nv50_ir::nvc0_selpFlip)
blob_write_uint8(blob, FLIP_NVC0);
else if (fixup->entry[i].apply == nv50_ir::gk110_selpFlip)
blob_write_uint8(blob, FLIP_GK110);
else if (fixup->entry[i].apply == nv50_ir::gm107_selpFlip)
blob_write_uint8(blob, FLIP_GM107);
else if (fixup->entry[i].apply == nv50_ir::gv100_selpFlip)
blob_write_uint8(blob, FLIP_GV100);
else {
ERROR("unhandled fixup apply function pointer\n");
assert(false);
return false;
}
}
}
blob_write_uint8(blob, info_out->numInputs);
blob_write_uint8(blob, info_out->numOutputs);
blob_write_uint8(blob, info_out->numSysVals);
blob_write_bytes(blob, info_out->sv, info_out->numSysVals * sizeof(info_out->sv[0]));
blob_write_bytes(blob, info_out->in, info_out->numInputs * sizeof(info_out->in[0]));
blob_write_bytes(blob, info_out->out, info_out->numOutputs * sizeof(info_out->out[0]));
switch(info_out->type) {
case PIPE_SHADER_VERTEX:
blob_write_bytes(blob, &info_out->prop.vp, sizeof(info_out->prop.vp));
break;
case PIPE_SHADER_TESS_CTRL:
case PIPE_SHADER_TESS_EVAL:
blob_write_bytes(blob, &info_out->prop.tp, sizeof(info_out->prop.tp));
break;
case PIPE_SHADER_GEOMETRY:
blob_write_bytes(blob, &info_out->prop.gp, sizeof(info_out->prop.gp));
break;
case PIPE_SHADER_FRAGMENT:
blob_write_bytes(blob, &info_out->prop.fp, sizeof(info_out->prop.fp));
break;
default:
break;
}
blob_write_bytes(blob, &info_out->io, sizeof(info_out->io));
blob_write_uint8(blob, info_out->numBarriers);
return true;
}
extern bool
nv50_ir_prog_info_out_deserialize(void *data, size_t size, size_t offset,
struct nv50_ir_prog_info_out *info_out)
{
struct blob_reader reader;
blob_reader_init(&reader, data, size);
blob_skip_bytes(&reader, offset);
info_out->target = blob_read_uint16(&reader);
info_out->type = blob_read_uint8(&reader);
info_out->numPatchConstants = blob_read_uint8(&reader);
info_out->bin.maxGPR = blob_read_uint16(&reader);
info_out->bin.tlsSpace = blob_read_uint32(&reader);
info_out->bin.smemSize = blob_read_uint32(&reader);
info_out->bin.codeSize = blob_read_uint32(&reader);
info_out->bin.code = (uint32_t *)MALLOC(info_out->bin.codeSize);
blob_copy_bytes(&reader, info_out->bin.code, info_out->bin.codeSize);
info_out->bin.instructions = blob_read_uint32(&reader);
info_out->bin.relocData = NULL;
/* Check if data contains RelocInfo */
uint32_t count = blob_read_uint32(&reader);
if (count) {
nv50_ir::RelocInfo *reloc =
CALLOC_VARIANT_LENGTH_STRUCT(nv50_ir::RelocInfo,
count * sizeof(*reloc->entry));
reloc->codePos = blob_read_uint32(&reader);
reloc->libPos = blob_read_uint32(&reader);
reloc->dataPos = blob_read_uint32(&reader);
reloc->count = count;
blob_copy_bytes(&reader, reloc->entry, sizeof(*reloc->entry) * reloc->count);
info_out->bin.relocData = reloc;
}
info_out->bin.fixupData = NULL;
/* Check if data contains FixupInfo */
count = blob_read_uint32(&reader);
if (count) {
nv50_ir::FixupInfo *fixup =
CALLOC_VARIANT_LENGTH_STRUCT(nv50_ir::FixupInfo,
count * sizeof(*fixup->entry));
fixup->count = count;
for (uint32_t i = 0; i < count; i++) {
fixup->entry[i].val = blob_read_uint32(&reader);
/* Assign back function pointer depending on stored enum */
enum FixupApplyFunc apply = (enum FixupApplyFunc)blob_read_uint8(&reader);
switch(apply) {
case APPLY_NV50:
fixup->entry[i].apply = nv50_ir::nv50_interpApply;
break;
case APPLY_NVC0:
fixup->entry[i].apply = nv50_ir::nvc0_interpApply;
break;
case APPLY_GK110:
fixup->entry[i].apply = nv50_ir::gk110_interpApply;
break;
case APPLY_GM107:
fixup->entry[i].apply = nv50_ir::gm107_interpApply;
break;
case APPLY_GV100:
fixup->entry[i].apply = nv50_ir::gv100_interpApply;
break;
case FLIP_NVC0:
fixup->entry[i].apply = nv50_ir::nvc0_selpFlip;
break;
case FLIP_GK110:
fixup->entry[i].apply = nv50_ir::gk110_selpFlip;
break;
case FLIP_GM107:
fixup->entry[i].apply = nv50_ir::gm107_selpFlip;
break;
case FLIP_GV100:
fixup->entry[i].apply = nv50_ir::gv100_selpFlip;
break;
default:
ERROR("unhandled fixup apply function switch case");
assert(false);
return false;
}
}
info_out->bin.fixupData = fixup;
}
info_out->numInputs = blob_read_uint8(&reader);
info_out->numOutputs = blob_read_uint8(&reader);
info_out->numSysVals = blob_read_uint8(&reader);
blob_copy_bytes(&reader, info_out->sv, info_out->numSysVals * sizeof(info_out->sv[0]));
blob_copy_bytes(&reader, info_out->in, info_out->numInputs * sizeof(info_out->in[0]));
blob_copy_bytes(&reader, info_out->out, info_out->numOutputs * sizeof(info_out->out[0]));
switch(info_out->type) {
case PIPE_SHADER_VERTEX:
blob_copy_bytes(&reader, &info_out->prop.vp, sizeof(info_out->prop.vp));
break;
case PIPE_SHADER_TESS_CTRL:
case PIPE_SHADER_TESS_EVAL:
blob_copy_bytes(&reader, &info_out->prop.tp, sizeof(info_out->prop.tp));
break;
case PIPE_SHADER_GEOMETRY:
blob_copy_bytes(&reader, &info_out->prop.gp, sizeof(info_out->prop.gp));
break;
case PIPE_SHADER_FRAGMENT:
blob_copy_bytes(&reader, &info_out->prop.fp, sizeof(info_out->prop.fp));
break;
default:
break;
}
blob_copy_bytes(&reader, &(info_out->io), sizeof(info_out->io));
info_out->numBarriers = blob_read_uint8(&reader);
return true;
}

1
src/gallium/drivers/nouveau/meson.build
View File

@ -142,6 +142,7 @@ files_libnouveau = files(
'codegen/nv50_ir_peephole.cpp',
'codegen/nv50_ir_print.cpp',
'codegen/nv50_ir_ra.cpp',
'codegen/nv50_ir_serialize.cpp',
'codegen/nv50_ir_ssa.cpp',
'codegen/nv50_ir_target.cpp',
'codegen/nv50_ir_target.h',