← Back to branch summary

~arosales/test/oprofile

« back to all changes in this revision

Viewing changes to libop/tests/alloc_counter_tests.c

  • Committer: Antonio Rosales
  • Date: 2013-03-28 08:40:26 UTC
  • Revision ID: antonio.rosales@canonical.com-20130328084026-gpqns1mkqd7cnr05
Move files up one directory.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libop/tests/alloc_counter_tests.c
 
1
/**
 
2
 * @file alloc_counter_tests.c
 
3
 *
 
4
 * @remark Copyright 2003 OProfile authors
 
5
 * @remark Read the file COPYING
 
6
 *
 
7
 * @author John Levon
 
8
 * @author Philippe Elie
 
9
 */
 
10
 
 
11
#include <stdlib.h>
 
12
#include <stdio.h>
 
13
 
 
14
#include "op_parse_event.h"
 
15
#include "op_alloc_counter.h"
 
16
#include "op_events.h"
 
17
#include "op_hw_config.h"
 
18
#include "op_cpu_type.h"
 
19
#include "op_events.h"
 
20
 
 
21
/* FIXME: alpha description events need 20 but when running test on x86
 
22
 * OP_MAX_COUNTERS is 8, so we can't use it */
 
23
#define MAX_EVENTS 20
 
24
 
 
25
 
 
26
/* some test are setup to fail in a known way */
 
27
enum failure_type {
 
28
        no_failure,
 
29
        fail_to_find_event,
 
30
        fail_to_alloc_counter
 
31
};
 
32
 
 
33
struct allocated_counter {
 
34
        op_cpu cpu_type;
 
35
        char  const * const * events;
 
36
        size_t alloc_map[MAX_EVENTS];
 
37
        /* expected failure for this test */
 
38
        enum failure_type failure;
 
39
};
 
40
 
 
41
 
 
42
/* not more than MAX_EVENTS string for all these arrays */
 
43
static char const * const events_alpha_ev4_1[] = {
 
44
        "ISSUES:4096:0:1:1",
 
45
        NULL
 
46
};
 
47
 
 
48
static char const * const events_alpha_ev4_2[] = {
 
49
        "UNKNOWN_EVENT:4096:0:1:1",
 
50
        NULL
 
51
};
 
52
 
 
53
static char const * const events_ppro_1[] = {
 
54
        "CPU_CLK_UNHALTED:4096:0:1:1",
 
55
        NULL
 
56
};
 
57
 
 
58
static char const * const events_ppro_2[] = {
 
59
        "CPU_CLK_UNHALTED:4096:0:1:1",
 
60
        "DATA_MEM_REFS:4096:0:1:1",
 
61
        NULL
 
62
};
 
63
 
 
64
static char const * const events_ppro_3[] = {
 
65
        /* fail_to_alloc_counter: 2 event to counter 0 */
 
66
        "COMP_FLOP_RET:4096:0:1:1",
 
67
        "FLOPS:4096:0:1:1",
 
68
        NULL
 
69
};
 
70
 
 
71
static char const * const events_ppro_4[] = {
 
72
        "FLOPS:4096:0:1:1",
 
73
        "FP_ASSIST:4096:0:1:1",
 
74
        NULL
 
75
};
 
76
 
 
77
static char const * const events_ppro_5[] = {
 
78
        "FP_ASSIST:4096:0:1:1",
 
79
        "FLOPS:4096:0:1:1",
 
80
        NULL
 
81
};
 
82
 
 
83
static char const * const events_p4_1[] = {
 
84
        "BRANCH_RETIRED:4096:1:1:1",
 
85
        "MISPRED_BRANCH_RETIRED:4096:1:1:1",
 
86
        "BPU_FETCH_REQUEST:4096:1:1:1",
 
87
        "ITLB_REFERENCE:4096:1:1:1",
 
88
        "MEMORY_CANCEL:4096:4:1:1",
 
89
        "MEMORY_COMPLETE:4096:1:1:1",
 
90
        "TC_MS_XFER:4096:1:1:1",
 
91
        "UOP_QUEUE_WRITES:4096:1:1:1",
 
92
        NULL
 
93
};
 
94
 
 
95
static char const * const events_p4_2[] = {
 
96
        /* fail_to_alloc_counter: 3 event to counter 3, 7 */
 
97
        "BRANCH_RETIRED:4096:1:1:1",
 
98
        "MISPRED_BRANCH_RETIRED:4096:1:1:1",
 
99
        "INSTR_RETIRED:4096:1:1:1",
 
100
        "BPU_FETCH_REQUEST:4096:1:1:1",
 
101
        "ITLB_REFERENCE:4096:1:1:1",
 
102
        "MEMORY_CANCEL:4096:4:1:1",
 
103
        "MEMORY_COMPLETE:4096:1:1:1",
 
104
        "TC_MS_XFER:4096:1:1:1",
 
105
        NULL
 
106
};
 
107
 
 
108
static char const * const events_mips_34k[] = {
 
109
        /* fail_to_alloc_counter: w/o 2006-8-03  Jeremiah Lott patch, see
 
110
         * ChangeLog */
 
111
        "DTLB_MISSES:500:0:1:1",
 
112
        "JR_31_INSNS:500:0:1:1",
 
113
        NULL
 
114
};
 
115
 
 
116
static struct allocated_counter const tests[] = {
 
117
        { CPU_AXP_EV4, events_alpha_ev4_1, { 0 }, no_failure },
 
118
        { CPU_AXP_EV4, events_alpha_ev4_2, { -1 }, fail_to_find_event },
 
119
        { CPU_PPRO, events_ppro_1, { 0 }, no_failure },
 
120
        { CPU_PPRO, events_ppro_2, { 0, 1 }, no_failure },
 
121
        { CPU_PPRO, events_ppro_3, { -1 }, fail_to_alloc_counter },
 
122
        { CPU_PPRO, events_ppro_4, { 0, 1 }, no_failure },
 
123
        { CPU_PPRO, events_ppro_5, { 1, 0 }, no_failure },
 
124
        { CPU_P4, events_p4_1, { 3, 7, 0, 4, 2, 6, 1, 5 }, no_failure },
 
125
        { CPU_P4, events_p4_2, { -1 }, fail_to_alloc_counter },
 
126
        { CPU_MIPS_34K, events_mips_34k, { 1, 0 }, no_failure },
 
127
        { CPU_NO_GOOD, 0, { 0 }, 0 }
 
128
};
 
129
 
 
130
 
 
131
static void show_events(char const * const * events)
 
132
{
 
133
        for ( ; *events; ++events)
 
134
                printf("%s\n", *events);
 
135
}
 
136
 
 
137
 
 
138
static void show_counter_map(size_t const * counter_map, size_t nr_events)
 
139
{
 
140
        size_t i;
 
141
        for (i = 0; i < nr_events; ++i)
 
142
                printf("%lu ", (unsigned long)counter_map[i]);
 
143
        printf("\n");
 
144
}
 
145
 
 
146
 
 
147
static void do_test(struct allocated_counter const * it)
 
148
{
 
149
        size_t i;
 
150
        size_t * counter_map;
 
151
        size_t nr_events;
 
152
        struct parsed_event parsed[MAX_EVENTS];
 
153
        struct op_event const * event[MAX_EVENTS];
 
154
 
 
155
        op_events(it->cpu_type);
 
156
 
 
157
        nr_events = parse_events(parsed, MAX_EVENTS, it->events);
 
158
 
 
159
        for (i = 0; i < nr_events; ++i) {
 
160
                event[i] = find_event_by_name(parsed[i].name, parsed[i].unit_mask,
 
161
                                              parsed[i].unit_mask_valid);
 
162
                if (!event[i]) {
 
163
                        if (it->failure == fail_to_find_event)
 
164
                                goto free_events;
 
165
                        printf("Can't find events %s for cpu %s\n",
 
166
                               parsed[i].name,
 
167
                               op_get_cpu_type_str(it->cpu_type));
 
168
                        exit(EXIT_FAILURE);
 
169
                }
 
170
        }
 
171
 
 
172
        counter_map =  map_event_to_counter(event, nr_events, it->cpu_type);
 
173
        if (!counter_map) {
 
174
                if (it->failure == fail_to_alloc_counter)
 
175
                        goto free_events;
 
176
                printf("Can't map this set of events to counter:\n");
 
177
                show_events(it->events);
 
178
                exit(EXIT_FAILURE);
 
179
        }
 
180
 
 
181
        for (i = 0; i < nr_events; ++i) {
 
182
                if (counter_map[i] != it->alloc_map[i]) {
 
183
                        printf("Incorrect allocation map for these events:\n");
 
184
                        show_events(it->events);
 
185
                        printf("(expect, found):\n");
 
186
                        show_counter_map(it->alloc_map, nr_events);
 
187
                        show_counter_map(counter_map, nr_events);
 
188
                        exit(EXIT_FAILURE);
 
189
                }
 
190
        }
 
191
 
 
192
        if (it->failure != no_failure) {
 
193
                /* test should fail but success! */
 
194
                printf("test should fail with a failure type %d but succeed "
 
195
                       "for events:\n", it->failure);
 
196
                for (i = 0; i < nr_events; ++i)
 
197
                        printf("%s\n", it->events[i]);
 
198
                exit(EXIT_FAILURE);
 
199
        }
 
200
 
 
201
        free(counter_map);
 
202
free_events:
 
203
        op_free_events();
 
204
}
 
205
 
 
206
 
 
207
int main(void)
 
208
{
 
209
        struct allocated_counter const * it;
 
210
 
 
211
        setenv("OPROFILE_EVENTS_DIR", OPROFILE_SRCDIR "/events", 1);
 
212
 
 
213
        for (it = tests; it->cpu_type != CPU_NO_GOOD; ++it)
 
214
                do_test(it);
 
215
 
 
216
        return 0;
 
217
}