pstack/templates/types.cpp at master · POETSII/pstack · 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
// cprintf (conditional printf): simple function that either passes arguments
// or does nothing, depending on the flag `print_debug`.

int print_debug = {{ '1' if options['debug'] else '0' }};

void cprintf(const char *fmt, ...) {

    if (!print_debug)
        return;

    va_list va;
    va_start (va, fmt);
    vprintf (fmt, va);
    va_end (va);
}

// Base types

class msg_t {
    // Base message type
public:
    uint32_t index = 0;
    uint32_t nscalars = 0; // number of scalar fields
    virtual void print() = 0;
    virtual const char* getName() = 0;
    virtual void serialize(char *buf) = 0;
    virtual void deserialize(char *buf) = 0;
    virtual void read_debug() = 0;
    virtual int to_arr(int *arr, int arr_length) = 0;
    virtual int getByteCount() = 0;
};

// Simulation types

class destination_t {

public:

    void *device = NULL;
    int port;

    destination_t(void *device, int port) {
        this->device = device;
        this->port = port;
    }

    void print();

};

typedef std::vector<destination_t> dst_list_t;
typedef std::set<int> reg_set_t;

class device_t {

protected:
    dst_list_t* dsts; // destination devices by output port
    reg_set_t* regs; // destination regions by output port

public:
    std::string name = "n/a";
    uint32_t index = 0;
    uint32_t region = 0;
    virtual void init() = 0;
    virtual void print() = 0;
    virtual int get_rts() = 0;
    virtual void receive(int, msg_t*) = 0;
    virtual msg_t* send(int) = 0;
    virtual msg_t* generate_output_msg(int, int*) = 0;
    virtual int getOutputPortCount() = 0;
    virtual const char* getOutputPortName(int) = 0;
    virtual const char* getInputPortName(int) = 0;

    dst_list_t* getPortDestinations(int port_id) {
        return dsts + port_id;
    }

    reg_set_t* getPortOutputRegions(int port_id) {
        return regs + port_id;
    }

};

void destination_t::print() {

    device_t* device = (device_t*) (this->device);

    cprintf("  - Destination: device <%s> (input port <%s>)\n",
        (*device).name.c_str(),
        (*device).getInputPortName(port)
    );
}

class delivery_t {

public:

    device_t *origin;
    msg_t *msg;
    dst_list_t dst;

    delivery_t(msg_t* msg, dst_list_t dst, device_t *origin) {
        this->origin = origin;
        this->msg = msg;
        this->dst = dst;
    }

    void print_destinations() {
        for (int i=0; i<dst.size(); i++) {
            destination_t dest = dst.at(i);
            device_t* dev = (device_t*) dest.device;
            cprintf("<%s> ", dev->name.c_str());
        }
        cprintf("\n");
    }

    void print() {
        cprintf("Delivery of the following <%s> message:\n", (*msg).getName());
        (*msg).print();
        cprintf("To the following nodes:\n");
        for (int i=0; i<dst.size(); i++) {
            destination_t dest = dst.at(i);
            dest.print();
        }
    }
};