GTReplay: Mem Sample Tool

The Mem tool implements a simple memory model

Running Mem tool

To run the Mem tool in its default configuration, use this command:

Profilers\GTReplay\intel64\gtreplay.exe -t mem -- path-to-the-directory-containing-the-trace

(Back to the list of all GTReplay Sample Tools)

mem.cpp

/*========================== begin_copyright_notice ============================
Copyright (C) 2021-2022 Intel Corporation

SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/

/*******************************************************************************************************
 * MEM tool
 *
 * Simple memory model - follow writes to global memory.
 *
 * NOTE: the tool callbacks might be called from different threads.
 */
#include <mutex>
#include <stdio.h>
#include <string.h>

#include "gtreplay_assert.h"
#include "gtreplay_client.h"
#include "knob_parser.h"
#include "mem_model.h"

// Global variables
uint8_t* sendDecodeData;

uint32_t   gMaxNumOfHwThreads = 0;
uint32_t   gNumOfInstructions = 0;

MemoryModel mem;
std::mutex mem_mutex;
uint32_t count = 0;
uint64_t max_addr = 0;

/*
 * BeforeInsCallback - callback called before instruction execution
 *
 * @params[in] tid - the ID of the GPU HW thread for which the callback is called
 * @params[in] ins - a handle to the current instruction
 * @params[in] state - a handle to the HW Thread state corresponding to tid
 */
void BeforeInsCallback(uint32_t tileId, uint32_t tid, GTReplayIns ins, GTReplayState state, void*)
{
    // Lock is required since this callback can be called from different threads
    std::lock_guard<std::mutex> lock(mem_mutex);

    GTREPLAY_ASSERT(GTReplay_IsMemoryWrite(ins));

    uint32_t id = GTReplay_InsId(ins);

    // Obtain attributes of access for this instruction
    uint32_t numOfAccesses = GTReplay_GetNumOfMemoryAccesses(ins); // number of accesses
    uint32_t surfaceId     = GTReplay_GetMemorySurfaceId(ins);     // surface ID (BTI)
    uint32_t memAccessSize = GTReplay_GetMemoryAccessSize(ins);    // memory access size
    
    // Obtain the dynamic execution mask - active channels
    uint32_t chan = GTReplay_DynamicExecMask(ins,  state);

    // Iterate over all accesses
    for (uint32_t i = 0; i < numOfAccesses; i++)
    {
        uint8_t data[32] = {};

        // If the current channel is active
        if (chan & (1 << i))
        {
            // Obtain the current access address
            uint64_t addr = GTReplay_GetMemoryAccessAddr(ins, state, i);
            // Obtain the current access value
            GTReplay_GetMemoryWriteValue(ins, state, i, data);

            uint32_t* d = (uint32_t*)data;

            // Write to memory in granularity of 4 bytes
            for (uint32_t e = 0; e < memAccessSize / 4; e++)
            {
                mem.Write(surfaceId, (uint32_t)addr, d[0]);

                if (addr > max_addr) max_addr = addr;

                count += 4;
                addr += 4;
                d++;
            }
        }
    }
}

/*
 * AfterInsCallback - callback called after instruction execution
 *                    An illustration - this tool doesn't need to register after instruction callbacks
 *
 * @params[in] tid - the ID of the GPU HW thread for which the callback is called
 * @params[in] ins - a handle to the current instruction
 * @params[in] state - a handle to the HW Thread state corresponding to tid
 */
void AfterInsCallback(uint32_t tileId, uint32_t tid, GTReplayIns ins, GTReplayState state, void*)
{
}

/*
 * OnKernelComplete - callback called upon kernel completion
 *
 * @params[in] kernel - a handle to the kernel
 */
void OnKernelComplete(GTReplayKernel kernel)
{
    // Print the results
    printf("\n\n=================\n"
           "MEM TOOL\n"
           "=================\n\n");

    printf("written memory = 0x%08x bytes max_addr = 0x%016llx\n", count, max_addr);

    // Print the resulting memory image
    mem.Print(true);
}

/*
 * OnKernelBuild - callback called before kernel execution
 *                 The purpose of this callback is to traverse the kernel binary and instrument callbacks
 *
 * @params[in] kernel - a handle to the kernel
 */
void OnKernelBuild(GTReplayKernel kernel)
{
    uint32_t gModelId = GTReplay_GetModel(kernel);

    gMaxNumOfHwThreads = GTReplay_MaxNumOfHWThreads(gModelId);

    gNumOfInstructions = GTReplay_NumOfInstructions(kernel);
    
    // Traverse all the basic blocks 
    for (GTReplayBbl bbl = GTReplay_BblHead(kernel); GTReplay_BblValid(bbl); bbl = GTReplay_BblNext(bbl))
    {
        // Traverse all the instruction within the basic blocks 
        for (GTReplayIns ins = GTReplay_InsHead(bbl); GTReplay_InsValid(ins); ins = GTReplay_InsNext(ins))
        {
            // Check whether the instruction is memory write
            if (!GTReplay_IsMemoryWrite(ins))
            {
                // If not, there is nothing to do
                continue;
               }
            // Register callback to be called before instruction execution
            GTReplay_RegisterCallbackBeforeIns(kernel, ins, BeforeInsCallback, NULL);
        }
    }
}

/*
 * GTReplay_Entry - tool entry point
 */
extern "C"
DLLEXP void FASTCALL GTReplay_Entry(int argc, const char *argv[])
{
    // configure GTReplay
    ConfigureGTReplay(argc, argv);
    
    // register OnKernelBuild and OnKernelComplete callbacks
    GTReplay_RegisterOnKernelBuildCallback(OnKernelBuild);
    GTReplay_RegisterOnKernelCompleteCallback(OnKernelComplete);

    // Start GTReplay
    GTReplay_Start();
}

mem_model.h

/*========================== begin_copyright_notice ============================
Copyright (C) 2021 Intel Corporation

SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/

#ifndef _MEM_MODEL_H
#define _MEM_MODEL_H

#include <cstring>
#include <mutex>


#define FOUR_MB (4 * 1024 * 1024)
#define FOUR_KB (4 * 1024)

/*
 * Surface - represents a memory buffer
 */
class Surface {
public:
    // Constructor
    Surface();

    // Destructor
    ~Surface();
    
    // Writing into the surface
    // 
    // addr - an offset into the surface
    // data - data to be written
    void Write(uint32_t addr, uint32_t data);

    // Printing the surface image
    void Print(bool asFloat);


private:

    // Computes the pointer to the surface corresponding to the given address
    uint8_t * GetPtr(uint32_t addr);

    // PageTable - represents a 4KB page table where each entry points to a 4KB page
    typedef struct PageTableS {
        // Initially each page table is empty
        PageTableS() { memset(pte, 0, 1024 * sizeof(uint32_t*)); }
        uint32_t* pte[1024];
    } PageTable;

    PageTable*   _pageDir[1024]; // Page directory is an array of 1024 pointers to page tables

    uint32_t _numOfWrites;  // number of writes
    uint32_t _maxAddr;      // maximal address
};
    
/*
 * MemoryModel - a simple memory model
 */ 
class MemoryModel {
public:

    // Constructor
    MemoryModel();
    
    // Destructor
    ~MemoryModel();

    // Writing into a surface
    // 
    // bti  - surface ID (BTI index)
    // addr - an offset into the surface
    // data - data to be written
    void Write(uint32_t bti, uint32_t addr, uint32_t data);

    // Printing the memory image
    void Print(bool asFloat);

private:

    Surface*   _mem[256];   // an array of potential 256 surfaces

    std::mutex _mutex;      // mutex
};

#endif

mem_model.cpp

/*========================== begin_copyright_notice ============================
Copyright (C) 2021 Intel Corporation

SPDX-License-Identifier: MIT
============================= end_copyright_notice ===========================*/

#include "mem_model.h"
#include <cstdio>

// MemoryModel constructor
MemoryModel::MemoryModel()
{
    // Initially all surface pointers are NULL
    for (uint32_t bti = 0; bti < 256; bti++)
    {
        _mem[bti] = NULL;
    }
}
    
// MemoryModel destructor
MemoryModel::~MemoryModel()
{
    // Iterate over all potential surfaces
    for (uint32_t bti = 0; bti < 256; bti++)
    {
        // If exists
        if (_mem[bti])
        {
            // Delete it
            delete _mem[bti];
        }
    }
}

// Writing into a surface
// 
// bti  - surface ID (BTI index)
// addr - an offset into the surface
// data - data to be written
void MemoryModel::Write(uint32_t bti, uint32_t addr, uint32_t data)
{
    std::lock_guard<std::mutex> lock(_mutex);

    // If first access to the specific surface
    if (_mem[bti] == NULL)
    {
        // Create it
        _mem[bti] = new Surface;
    }
    
    // Perform a write into the surface
    _mem[bti]->Write(addr, data);
}

// Printing the memory image
void MemoryModel::Print(bool asFloat)
{
    // Iterate over all potential surfaces
    for (uint32_t bti = 0; bti < 256; bti++)
    {
        // If exists
        if (_mem[bti])
        {
            printf("\nSurface: 0x%02x\n=============\n\n", bti);

            // Print the surface
            _mem[bti]->Print(asFloat);
        }
    }
}


// Surface constructor
Surface::Surface() : _numOfWrites(0), _maxAddr(0)
{
    // Page Directory is initially empty
    memset(_pageDir, 0, 1024 * sizeof(PageTable*));
}

// Surface destructor
Surface::~Surface()
{
    // Iterate over all Page Directory entries
    for (uint32_t pdi = 0; pdi < 1024; pdi++)
    {
        PageTable* pageTable = _pageDir[pdi];

        // If current Page Table exists
        if (pageTable)
        {
            // Iterate over all Page Table entries
            for (uint32_t pti = 0; pti < 1024; pti++)
            {
                uint32_t* page = pageTable->pte[pti];

                // If page exists
                if (page)
                {
                    // Delete it
                    delete[] page;
                    pageTable->pte[pti] = NULL;
                }
            }

            // Delete Page Table
            delete pageTable;
            _pageDir[pdi] = NULL;
        }
    }
}

// Writing into the surface
// 
// addr - an offset into the surface
// data - data to be written
void Surface::Write(uint32_t addr, uint32_t data)
{
    // Update statistics
    _numOfWrites++;
    if (_maxAddr < addr)
    {
        _maxAddr = addr;
    }

    // Get a pointer to required offset
    uint32_t* ptr = (uint32_t*)GetPtr(addr);

    // Write the data
    ptr[0] = data;
}


// Printing the surface image
void Surface::Print(bool asFloat)
{
    // Print surface statistics
    printf("Surface: numOfWrites = %d maxAddr = 0x%08x\n", _numOfWrites, _maxAddr);

    // Iterate over all entries within the Page Directory
    for (uint32_t pdi = 0; pdi < 1024; pdi++)
    {
        PageTable* pageTable = _pageDir[pdi];

        // If corresponding Page Table exists
        if (pageTable)
        {
            // Compute the base described by the current Page Table
            uint32_t pageTableBase = pdi * FOUR_MB;

            // Iterate over all Page Table entries
            for (uint32_t pti = 0; pti < 1024; pti++)
            {
                uint32_t* page = pageTable->pte[pti];

                // If the current page exists
                if (page)
                {
                    // Compute the base of the current page
                    uint32_t pageBase = pageTableBase + pti * FOUR_KB;

                    // Dump all 4bytes of the current page
                    for (uint32_t a = 0; a < 1024; a++)
                    {
                        uint32_t addr = pageBase + a * 4;
                        uint32_t val  = page[a];

                        if (asFloat) printf("0x%08x: 0x%08x (%f)\n", addr, val, *(float*)&val);
                        else         printf("0x%08x: 0x%08x\n", addr, val);
                    }
                }
            }
        }
    }
}


// Computes the pointer to the surface corresponding to the given address
uint8_t * Surface::GetPtr(uint32_t addr)
{
    // Compute Page Directory index, Page Table index and the offset into the page from the address
    uint32_t pdi = addr >> 22;
    uint32_t pti = (addr & 0x003FF000) >> 12;
    uint32_t offset = addr & 0xFFF;

    // Get corresponding Page Table
    PageTable* pageTable = _pageDir[pdi];

    // If doesn't exist
    if (pageTable == NULL)
    {
        // Allocate one
        pageTable = new PageTable;

        // Update Page Directory
        _pageDir[pdi] = pageTable;
    }

    // Compute the current page
    uint32_t* page = pageTable->pte[pti];

    // If doesn't exist
    if (page == NULL)
    {
        // Allocate one
        page = new uint32_t[1024];
        // Initialize with zeros
        memset(page, 0, 0x1000);
        // Update Page Table
        pageTable->pte[pti] = page;
    }

    // Compute the pointer into the current page
    uint8_t* ptr = (uint8_t*)page + offset;

    return ptr;
}

(Back to the list of all GTReplay Sample Tools)