MemTrace-Pin/parse.cpp at main · HieronZhang/MemTrace-Pin · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
#include <iostream>
#include <fstream>
#include <unordered_set>
#include <queue>
#include <vector>
#include <stdint.h>
#include <string.h>

using std::ifstream;
using std::ofstream;
struct TraceSample
{
    uint64_t ns;
    uint64_t addr;
    uint8_t r;
    uint8_t size;
} __attribute((__packed__));

// Using a custom function object to compare elements.
struct
{
    bool operator()(const TraceSample* l, const TraceSample* r) const { return l->ns > r->ns; }
} customLess;

int main(int argc, char **argv)
{
    int thread_num;
    uint64_t cl_foot_print = 0;
    uint64_t page_foot_print = 0;
    std::unordered_set<uint64_t> access_addr;
    std::unordered_set<uint64_t> access_addr_page;
    std::vector<TraceSample*> data;

    if (argc == 3)
    {
        thread_num = std::stoi(argv[1]);
    }
    else
    {
        printf("Usage: ./parse core_num fortxt\n");
        printf("fortxt : 1 only for footprint, 0 for uncompressed txt file\n");
        exit(0);
    }

    if (strcmp(argv[2], "2") == 0)
    {


        for (int i = 0; i < thread_num; i++)
        {
            std::string filename = "pinatrace.out." + std::to_string(i);
            std::string filename_txt = "pinatrace.out." + std::to_string(i) + ".txt";
            ifstream fin(filename);

            while (!fin.eof())
            {
                TraceSample *sample = new TraceSample;
                char* byte_arr = (char*) sample;
                fin.read(byte_arr, sizeof(TraceSample));
                if (sample->ns!=0)
                {
                    data.push_back(sample);
                    //std::cout << sample->ns << " " << sample->addr << " " << sample->r << " " << int(sample->size) << std::endl;
                }
            }
        }
        // std::priority_queue<TraceSample*, std::vector<TraceSample*>, decltype(customLess)> overall_accesses(data.begin(), data.end(), customLess);
        // ofstream outputFile;
        // outputFile.open("overall.trace");
        // for (; !overall_accesses.empty(); overall_accesses.pop())
        // {
        //     TraceSample* sample1 = overall_accesses.top();
        //     //outputFile << sample1->ns << " " << sample1->addr << " " << sample1->r << " " << int(sample1->size) << std::endl;
        //     outputFile.write((char *)sample1, sizeof(TraceSample));
        // }

        for (size_t i = 0; i < data.size(); i++)
        {
            delete data[i];
        }

        return 0;
    }

    for (int i = 0; i < thread_num; i++)
    {
        std::string filename = "pinatrace.out." + std::to_string(i);
        std::string filename_txt = "pinatrace.out." + std::to_string(i) + ".txt";
        ifstream fin(filename);
        ofstream outputFile;
        if (strcmp(argv[2], "0") == 0)
            outputFile.open(filename_txt);

        char byte_arr[sizeof(TraceSample)];
        TraceSample *sample = (TraceSample *)byte_arr;

        long num_lines = 0;

        while (!fin.eof() && num_lines <= 6710886)   // At most 6710886 lines per thread trace, which ensures at most 2GB for all 16 thread traces
        {
            fin.read(byte_arr, sizeof(TraceSample));
            if (access_addr.insert(sample->addr).second)
            {
                cl_foot_print += 64;
            }
            if (access_addr_page.insert(sample->addr / (64 * 64)).second)
            {
                page_foot_print += 4096;
            }

            if (strcmp(argv[2], "0") == 0)
                outputFile << (sample->r == (uint8_t)'R'? "LD" : "ST") << " " << sample->addr << std::endl;
                num_lines++;
            // outputFile.write()
            // char buffer [100];
            // snprintf ( buffer, 100, "The half of %d is %d", 60, 60/2 );
            // printf("ns: %20ld, addr: 0x%016lx, r: %c, size: %2d\n",
            //     sample->ns, sample->addr, sample->r, sample->size);
            // }
        }

        if (strcmp(argv[2], "0") == 0)
            outputFile.close();
    }
    printf("clfoot_print: %20ld \n", cl_foot_print);
    printf("page_foot_print: %20ld \n", page_foot_print);
}