← Back to branch summary

~ubuntu-branches/ubuntu/utopic/numactl/utopic

« back to all changes in this revision

Viewing changes to test/randmap.c

  • Committer: Bazaar Package Importer
  • Author(s): Ian Wienand
  • Date: 2005-11-25 17:04:25 UTC
  • Revision ID: james.westby@ubuntu.com-20051125170425-62ged0kz3ztiqazq
Tags: upstream-0.7pre2
Import upstream version 0.7pre2

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/randmap.c
 
1
/* Randomly change policy */ 
 
2
#include <stdio.h>
 
3
#include "numaif.h"
 
4
#include <sys/mman.h>
 
5
#include <sys/shm.h>
 
6
#include <sys/ipc.h>
 
7
#include <stdlib.h>
 
8
#include <time.h>
 
9
#include <unistd.h>
 
10
#include <string.h>
 
11
#include <errno.h>
 
12
 
 
13
#define SIZE (100*1024*1024) 
 
14
#define PAGES (SIZE/pagesize)
 
15
 
 
16
#define perror(x) printf("%s: %s\n", x, strerror(errno))
 
17
#define err(x) perror(x),exit(1)
 
18
 
 
19
struct page { 
 
20
        unsigned long mask; 
 
21
        int policy;
 
22
};
 
23
 
 
24
struct page *pages;
 
25
char *map;
 
26
int pagesize;
 
27
 
 
28
void setpol(unsigned long offset, unsigned long length, int policy, unsigned long nodes)
 
29
{
 
30
        long i, end;
 
31
 
 
32
        printf("off:%lx length:%lx policy:%d nodes:%lx\n",
 
33
               offset, length, policy, nodes);
 
34
        
 
35
        if (mbind(map + offset*pagesize, length*pagesize, policy,
 
36
                  &nodes, 8, 0) < 0) {
 
37
                printf("mbind: %s offset %lx length %lx policy %d nodes %lx\n", 
 
38
                       strerror(errno),
 
39
                       offset*pagesize, length*pagesize,
 
40
                       policy, nodes);
 
41
                return;
 
42
        }
 
43
 
 
44
        for (i = offset; i < offset+length; i++) { 
 
45
                pages[i].mask = nodes;
 
46
                pages[i].policy = policy;
 
47
        }
 
48
 
 
49
        i = offset - 20;
 
50
        if (i < 0) 
 
51
                i = 0; 
 
52
        end = offset+length+20; 
 
53
        if (end > PAGES)
 
54
                end = PAGES;
 
55
        for (; i < end; i++) { 
 
56
                int pol2;
 
57
                unsigned long nodes2;
 
58
                if (get_mempolicy(&pol2, &nodes2, sizeof(long)*8, map+i*pagesize, 
 
59
                                  MPOL_F_ADDR) < 0)
 
60
                        err("get_mempolicy");
 
61
                if (pol2 != pages[i].policy) { 
 
62
                        printf("%lx: got policy %d expected %d, nodes got %lx expected %lx\n",
 
63
                               i,
 
64
                               pol2, pages[i].policy, nodes2, pages[i].mask);
 
65
                }
 
66
                if (policy != MPOL_DEFAULT && nodes2 != pages[i].mask) { 
 
67
                        printf("%lx: nodes %lx, expected %lx, policy %d\n",
 
68
                               i, nodes2, pages[i].mask, policy);
 
69
                }
 
70
        } 
 
71
}
 
72
 
 
73
static unsigned char pop4[16] = {
 
74
  0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4
 
75
}; 
 
76
 
 
77
int popcnt(unsigned long val)
 
78
{ 
 
79
        int count = 0;
 
80
        while (val) { 
 
81
                count += pop4[val & 0xf];
 
82
                val >>= 4; 
 
83
        }
 
84
        return count;
 
85
} 
 
86
 
 
87
void testmap(void) 
 
88
{ 
 
89
 
 
90
        pages = calloc(1, PAGES * sizeof(struct page)); 
 
91
        if (!pages)
 
92
                exit(100);
 
93
 
 
94
        printf("simple tests\n");
 
95
#define MB ((1024*1024)/pagesize)
 
96
        setpol(0, PAGES, MPOL_INTERLEAVE, 3); 
 
97
        setpol(0, MB, MPOL_BIND, 1); 
 
98
        setpol(MB, MB, MPOL_BIND, 1); 
 
99
        setpol(MB, MB, MPOL_DEFAULT, 0); 
 
100
        setpol(MB, MB, MPOL_PREFERRED, 2); 
 
101
        setpol(MB/2, MB, MPOL_DEFAULT, 0); 
 
102
        setpol(MB+MB/2, MB, MPOL_BIND, 2); 
 
103
        setpol(MB/2+100, 100, MPOL_PREFERRED, 1); 
 
104
        setpol(100, 200, MPOL_PREFERRED, 1);
 
105
        printf("done\n");
 
106
 
 
107
        for (;;) {      
 
108
                unsigned long offset = random() % PAGES; 
 
109
                int policy = random() % (MPOL_MAX+1);
 
110
                unsigned long nodes = random() % 4;
 
111
                long length = random() % (PAGES - offset);
 
112
 
 
113
                /* validate */ 
 
114
                switch (policy) { 
 
115
                case MPOL_DEFAULT: 
 
116
                        nodes = 0;
 
117
                        break;
 
118
                case MPOL_INTERLEAVE:
 
119
                case MPOL_BIND:
 
120
                        if (nodes == 0) 
 
121
                                continue;
 
122
                        break;
 
123
                case MPOL_PREFERRED:
 
124
                        if (popcnt(nodes) != 1) 
 
125
                                continue;
 
126
                        break;
 
127
                } 
 
128
 
 
129
 
 
130
                setpol(offset, length, policy, nodes);
 
131
 
 
132
        } 
 
133
} 
 
134
 
 
135
int main(int ac, char **av)
 
136
{
 
137
        unsigned long seed;
 
138
 
 
139
        pagesize = getpagesize();
 
140
        
 
141
#if 0
 
142
        map = mmap(NULL, SIZE, PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, 0, 0);
 
143
        if (map == (char*)-1)
 
144
                err("mmap");
 
145
#else   
 
146
        int shmid = shmget(IPC_PRIVATE, SIZE, IPC_CREAT|0666); 
 
147
        if (shmid < 0) err("shmget");
 
148
        map = shmat(shmid, NULL, SHM_RDONLY);
 
149
        shmctl(shmid, IPC_RMID, NULL);
 
150
        if (map == (char *)-1) err("shmat");            
 
151
        printf("map %p\n", map);
 
152
#endif
 
153
 
 
154
        if (av[1]) { 
 
155
                char *end;
 
156
                unsigned long timeout = strtoul(av[1], &end, 0);
 
157
                switch (*end) { 
 
158
                case 'h': timeout *= 3600; break;
 
159
                case 'm': timeout *= 60; break;
 
160
                }
 
161
                printf("running for %lu seconds\n", timeout);
 
162
                alarm(timeout);
 
163
        } else
 
164
                printf("running forever\n");
 
165
 
 
166
        if (av[1] && av[2])
 
167
                seed = strtoul(av[2], 0, 0);
 
168
        else
 
169
                seed = time(0);
 
170
 
 
171
        printf("random seed %lu\n", seed); 
 
172
        srandom(seed);
 
173
 
 
174
        testmap();
 
175
        /* test shm etc. */
 
176
        return 0;
 
177
}