9 #include "process_test.h"
15 #define BLOCK_PARAS_SHIFT (BLOCK_SHIFT - PARA_SHIFT)
16 #define BLOCK_PARAS (1 << BLOCK_PARAS_SHIFT)
19 assert(sizeof(long) > sizeof(int));
20 return (int)((long)rand() * n / (RAND_MAX + 1L));
23 int calc_blocks(int para_base, int para_limit) {
25 ((para_limit + (BLOCK_PARAS - 1)) >> BLOCK_PARAS_SHIFT) -
26 (para_base >> BLOCK_PARAS_SHIFT);
35 int main(int argc, char **argv) {
37 printf("usage: %s n_processes pool_blocks n_events para_base para_limit [do_base [seed]]\n", argv[0]);
40 int n_processes = atoi(argv[1]);
41 int pool_blocks = atoi(argv[2]);
42 int n_events = atoi(argv[3]);
43 int para_base = atoi(argv[4]);
44 int para_limit = atoi(argv[5]);
45 bool do_base = argc >= 7 ? strcmp(argv[6], "false") != 0 : false;
46 int seed = argc >= 8 ? atoi(argv[7]) : 1;
48 rassert(para_limit >= para_base);
50 struct process *processes = malloc(n_processes * sizeof(struct process));
52 memset(processes, 0, n_processes * sizeof(struct process));
56 for (int i = 0; i < n_events; ++i) {
57 struct process_test test;
59 memset(&test, 0, sizeof(test));
62 test.process = rand_int(n_processes);
63 struct process *process = processes + test.process;
65 test.old_para_base = process->para_base;
66 test.old_para_limit = process->para_limit;
67 if (!process->active) {
69 (do_base ? rand_int(para_limit - para_base + 1) : 0) + para_base;
71 rand_int(para_limit - para_base + 1) + para_base;
72 if (test.para_base > test.para_limit) {
73 int i = test.para_base;
74 test.para_base = test.para_limit;
77 int blocks = calc_blocks(test.para_base, test.para_limit);
78 test.success = pool_used + blocks <= pool_blocks;
81 test.type = PROCESS_TEST_TYPE_ALLOC;
82 write(1, &test, sizeof(test));
85 "alloc %d %d %d %s\n",
89 test.success ? "true" : "false"
94 process->active = true;
95 process->para_base = test.para_base;
96 process->para_limit = test.para_limit;
101 int old_blocks = calc_blocks(process->para_base, process->para_limit);
104 test.type = PROCESS_TEST_TYPE_RUN;
105 write(1, &test, sizeof(test));
107 printf("run %d\n", test.process);
110 if (rand_int(8) == 0) {
111 if (do_base && rand_int(3) == 0) {
113 rand_int(process->para_limit - para_base + 1) +
115 int blocks = calc_blocks(test.para_base, process->para_limit);
116 test.success = pool_used + blocks - old_blocks <= pool_blocks;
119 test.type = PROCESS_TEST_TYPE_REALLOC_BASE;
120 write(1, &test, sizeof(test));
123 "realloc_base %d %d %d %s\n",
127 test.success ? "true" : "false"
132 process->para_base = test.para_base;
133 pool_used += blocks - old_blocks;
138 rand_int(para_limit - process->para_base + 1) +
140 int blocks = calc_blocks(process->para_base, test.para_limit);
141 test.success = pool_used + blocks - old_blocks <= pool_blocks;
144 test.type = PROCESS_TEST_TYPE_REALLOC;
145 write(1, &test, sizeof(test));
148 "realloc %d %d %d %s\n",
152 test.success ? "true" : "false"
157 process->para_limit = test.para_limit;
158 pool_used += blocks - old_blocks;
165 test.type = PROCESS_TEST_TYPE_FREE;
166 write(1, &test, sizeof(test));
175 process->active = false;
176 pool_used -= old_blocks;