EL4121 Embedded System / mbed-os

mbed-os

Dependents:   cobaLCDJoyMotor_Thread odometry_omni_3roda_v3 odometry_omni_3roda_v1 odometry_omni_3roda_v2 ... more

events/equeue/tests/prof.c@0:b74591d5ab33, 2017-12-11 (annotated)

Committer:
be_bryan
Date:
Mon Dec 11 17:54:04 2017 +0000
Revision:
0:b74591d5ab33
motor ++

Who changed what in which revision?

UserRevisionLine numberNew contents of line
be_bryan 0:b74591d5ab33 1 /*
be_bryan 0:b74591d5ab33 2 * Profiling framework for the events library
be_bryan 0:b74591d5ab33 3 *
be_bryan 0:b74591d5ab33 4 * Copyright (c) 2016 Christopher Haster
be_bryan 0:b74591d5ab33 5 *
be_bryan 0:b74591d5ab33 6 * Licensed under the Apache License, Version 2.0 (the "License");
be_bryan 0:b74591d5ab33 7 * you may not use this file except in compliance with the License.
be_bryan 0:b74591d5ab33 8 * You may obtain a copy of the License at
be_bryan 0:b74591d5ab33 9 *
be_bryan 0:b74591d5ab33 10 * http://www.apache.org/licenses/LICENSE-2.0
be_bryan 0:b74591d5ab33 11 *
be_bryan 0:b74591d5ab33 12 * Unless required by applicable law or agreed to in writing, software
be_bryan 0:b74591d5ab33 13 * distributed under the License is distributed on an "AS IS" BASIS,
be_bryan 0:b74591d5ab33 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
be_bryan 0:b74591d5ab33 15 * See the License for the specific language governing permissions and
be_bryan 0:b74591d5ab33 16 * limitations under the License.
be_bryan 0:b74591d5ab33 17 */
be_bryan 0:b74591d5ab33 18 #include "equeue.h"
be_bryan 0:b74591d5ab33 19 #include <unistd.h>
be_bryan 0:b74591d5ab33 20 #include <stdio.h>
be_bryan 0:b74591d5ab33 21 #include <setjmp.h>
be_bryan 0:b74591d5ab33 22 #include <stdint.h>
be_bryan 0:b74591d5ab33 23 #include <stdlib.h>
be_bryan 0:b74591d5ab33 24 #include <inttypes.h>
be_bryan 0:b74591d5ab33 25 #include <sys/time.h>
be_bryan 0:b74591d5ab33 26
be_bryan 0:b74591d5ab33 27
be_bryan 0:b74591d5ab33 28 // Performance measurement utils
be_bryan 0:b74591d5ab33 29 #define PROF_RUNS 5
be_bryan 0:b74591d5ab33 30 #define PROF_INTERVAL 100000000
be_bryan 0:b74591d5ab33 31
be_bryan 0:b74591d5ab33 32 #define prof_volatile(t) __attribute__((unused)) volatile t
be_bryan 0:b74591d5ab33 33
be_bryan 0:b74591d5ab33 34 typedef uint64_t prof_cycle_t;
be_bryan 0:b74591d5ab33 35
be_bryan 0:b74591d5ab33 36 static volatile prof_cycle_t prof_start_cycle;
be_bryan 0:b74591d5ab33 37 static volatile prof_cycle_t prof_stop_cycle;
be_bryan 0:b74591d5ab33 38 static prof_cycle_t prof_accum_cycle;
be_bryan 0:b74591d5ab33 39 static prof_cycle_t prof_baseline_cycle;
be_bryan 0:b74591d5ab33 40 static prof_cycle_t prof_iterations;
be_bryan 0:b74591d5ab33 41 static const char *prof_units;
be_bryan 0:b74591d5ab33 42
be_bryan 0:b74591d5ab33 43 #define prof_cycle() ({ \
be_bryan 0:b74591d5ab33 44 uint32_t a, b; \
be_bryan 0:b74591d5ab33 45 __asm__ volatile ("rdtsc" : "=a" (a), "=d" (b)); \
be_bryan 0:b74591d5ab33 46 ((uint64_t)b << 32) | (uint64_t)a; \
be_bryan 0:b74591d5ab33 47 })
be_bryan 0:b74591d5ab33 48
be_bryan 0:b74591d5ab33 49 #define prof_loop() \
be_bryan 0:b74591d5ab33 50 for (prof_iterations = 0; \
be_bryan 0:b74591d5ab33 51 prof_accum_cycle < PROF_INTERVAL; \
be_bryan 0:b74591d5ab33 52 prof_iterations++)
be_bryan 0:b74591d5ab33 53
be_bryan 0:b74591d5ab33 54 #define prof_start() ({ \
be_bryan 0:b74591d5ab33 55 prof_start_cycle = prof_cycle(); \
be_bryan 0:b74591d5ab33 56 })
be_bryan 0:b74591d5ab33 57
be_bryan 0:b74591d5ab33 58 #define prof_stop() ({ \
be_bryan 0:b74591d5ab33 59 prof_stop_cycle = prof_cycle(); \
be_bryan 0:b74591d5ab33 60 prof_accum_cycle += prof_stop_cycle - prof_start_cycle; \
be_bryan 0:b74591d5ab33 61 })
be_bryan 0:b74591d5ab33 62
be_bryan 0:b74591d5ab33 63 #define prof_result(value, units) ({ \
be_bryan 0:b74591d5ab33 64 prof_accum_cycle = value+prof_baseline_cycle; \
be_bryan 0:b74591d5ab33 65 prof_iterations = 1; \
be_bryan 0:b74591d5ab33 66 prof_units = units; \
be_bryan 0:b74591d5ab33 67 })
be_bryan 0:b74591d5ab33 68
be_bryan 0:b74591d5ab33 69 #define prof_measure(func, ...) ({ \
be_bryan 0:b74591d5ab33 70 printf("%s: ...", #func); \
be_bryan 0:b74591d5ab33 71 fflush(stdout); \
be_bryan 0:b74591d5ab33 72 \
be_bryan 0:b74591d5ab33 73 prof_units = "cycles"; \
be_bryan 0:b74591d5ab33 74 prof_cycle_t runs[PROF_RUNS]; \
be_bryan 0:b74591d5ab33 75 for (int i = 0; i < PROF_RUNS; i++) { \
be_bryan 0:b74591d5ab33 76 prof_accum_cycle = 0; \
be_bryan 0:b74591d5ab33 77 prof_iterations = 0; \
be_bryan 0:b74591d5ab33 78 func(__VA_ARGS__); \
be_bryan 0:b74591d5ab33 79 runs[i] = prof_accum_cycle / prof_iterations; \
be_bryan 0:b74591d5ab33 80 } \
be_bryan 0:b74591d5ab33 81 \
be_bryan 0:b74591d5ab33 82 prof_cycle_t res = runs[0]; \
be_bryan 0:b74591d5ab33 83 for (int i = 0; i < PROF_RUNS; i++) { \
be_bryan 0:b74591d5ab33 84 if (runs[i] < res) { \
be_bryan 0:b74591d5ab33 85 res = runs[i]; \
be_bryan 0:b74591d5ab33 86 } \
be_bryan 0:b74591d5ab33 87 } \
be_bryan 0:b74591d5ab33 88 res -= prof_baseline_cycle; \
be_bryan 0:b74591d5ab33 89 printf("\r%s: %"PRIu64" %s", #func, res, prof_units); \
be_bryan 0:b74591d5ab33 90 \
be_bryan 0:b74591d5ab33 91 if (!isatty(0)) { \
be_bryan 0:b74591d5ab33 92 prof_cycle_t prev; \
be_bryan 0:b74591d5ab33 93 while (scanf("%*[^0-9]%"PRIu64, &prev) == 0); \
be_bryan 0:b74591d5ab33 94 int64_t perc = 100*((int64_t)prev - (int64_t)res) / (int64_t)prev; \
be_bryan 0:b74591d5ab33 95 \
be_bryan 0:b74591d5ab33 96 if (perc > 10) { \
be_bryan 0:b74591d5ab33 97 printf(" (\e[32m%+"PRId64"%%\e[0m)", perc); \
be_bryan 0:b74591d5ab33 98 } else if (perc < -10) { \
be_bryan 0:b74591d5ab33 99 printf(" (\e[31m%+"PRId64"%%\e[0m)", perc); \
be_bryan 0:b74591d5ab33 100 } else { \
be_bryan 0:b74591d5ab33 101 printf(" (%+"PRId64"%%)", perc); \
be_bryan 0:b74591d5ab33 102 } \
be_bryan 0:b74591d5ab33 103 } \
be_bryan 0:b74591d5ab33 104 \
be_bryan 0:b74591d5ab33 105 printf("\n"); \
be_bryan 0:b74591d5ab33 106 res; \
be_bryan 0:b74591d5ab33 107 })
be_bryan 0:b74591d5ab33 108
be_bryan 0:b74591d5ab33 109 #define prof_baseline(func, ...) ({ \
be_bryan 0:b74591d5ab33 110 prof_baseline_cycle = 0; \
be_bryan 0:b74591d5ab33 111 prof_baseline_cycle = prof_measure(func, __VA_ARGS__); \
be_bryan 0:b74591d5ab33 112 })
be_bryan 0:b74591d5ab33 113
be_bryan 0:b74591d5ab33 114
be_bryan 0:b74591d5ab33 115 // Various test functions
be_bryan 0:b74591d5ab33 116 void no_func(void *eh) {
be_bryan 0:b74591d5ab33 117 }
be_bryan 0:b74591d5ab33 118
be_bryan 0:b74591d5ab33 119
be_bryan 0:b74591d5ab33 120 // Actual performance tests
be_bryan 0:b74591d5ab33 121 void baseline_prof(void) {
be_bryan 0:b74591d5ab33 122 prof_loop() {
be_bryan 0:b74591d5ab33 123 prof_start();
be_bryan 0:b74591d5ab33 124 __asm__ volatile ("");
be_bryan 0:b74591d5ab33 125 prof_stop();
be_bryan 0:b74591d5ab33 126 }
be_bryan 0:b74591d5ab33 127 }
be_bryan 0:b74591d5ab33 128
be_bryan 0:b74591d5ab33 129 void equeue_tick_prof(void) {
be_bryan 0:b74591d5ab33 130 prof_volatile(unsigned) res;
be_bryan 0:b74591d5ab33 131 prof_loop() {
be_bryan 0:b74591d5ab33 132 prof_start();
be_bryan 0:b74591d5ab33 133 res = equeue_tick();
be_bryan 0:b74591d5ab33 134 prof_stop();
be_bryan 0:b74591d5ab33 135 }
be_bryan 0:b74591d5ab33 136 }
be_bryan 0:b74591d5ab33 137
be_bryan 0:b74591d5ab33 138 void equeue_alloc_prof(void) {
be_bryan 0:b74591d5ab33 139 struct equeue q;
be_bryan 0:b74591d5ab33 140 equeue_create(&q, 32*EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 141
be_bryan 0:b74591d5ab33 142 prof_loop() {
be_bryan 0:b74591d5ab33 143 prof_start();
be_bryan 0:b74591d5ab33 144 void *e = equeue_alloc(&q, 8 * sizeof(int));
be_bryan 0:b74591d5ab33 145 prof_stop();
be_bryan 0:b74591d5ab33 146
be_bryan 0:b74591d5ab33 147 equeue_dealloc(&q, e);
be_bryan 0:b74591d5ab33 148 }
be_bryan 0:b74591d5ab33 149
be_bryan 0:b74591d5ab33 150 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 151 }
be_bryan 0:b74591d5ab33 152
be_bryan 0:b74591d5ab33 153 void equeue_alloc_many_prof(int count) {
be_bryan 0:b74591d5ab33 154 struct equeue q;
be_bryan 0:b74591d5ab33 155 equeue_create(&q, count*EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 156
be_bryan 0:b74591d5ab33 157 void *es[count];
be_bryan 0:b74591d5ab33 158
be_bryan 0:b74591d5ab33 159 for (int i = 0; i < count; i++) {
be_bryan 0:b74591d5ab33 160 es[i] = equeue_alloc(&q, (i % 4) * sizeof(int));
be_bryan 0:b74591d5ab33 161 }
be_bryan 0:b74591d5ab33 162
be_bryan 0:b74591d5ab33 163 for (int i = 0; i < count; i++) {
be_bryan 0:b74591d5ab33 164 equeue_dealloc(&q, es[i]);
be_bryan 0:b74591d5ab33 165 }
be_bryan 0:b74591d5ab33 166
be_bryan 0:b74591d5ab33 167 prof_loop() {
be_bryan 0:b74591d5ab33 168 prof_start();
be_bryan 0:b74591d5ab33 169 void *e = equeue_alloc(&q, 8 * sizeof(int));
be_bryan 0:b74591d5ab33 170 prof_stop();
be_bryan 0:b74591d5ab33 171
be_bryan 0:b74591d5ab33 172 equeue_dealloc(&q, e);
be_bryan 0:b74591d5ab33 173 }
be_bryan 0:b74591d5ab33 174
be_bryan 0:b74591d5ab33 175 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 176 }
be_bryan 0:b74591d5ab33 177
be_bryan 0:b74591d5ab33 178 void equeue_post_prof(void) {
be_bryan 0:b74591d5ab33 179 struct equeue q;
be_bryan 0:b74591d5ab33 180 equeue_create(&q, EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 181
be_bryan 0:b74591d5ab33 182 prof_loop() {
be_bryan 0:b74591d5ab33 183 void *e = equeue_alloc(&q, 0);
be_bryan 0:b74591d5ab33 184
be_bryan 0:b74591d5ab33 185 prof_start();
be_bryan 0:b74591d5ab33 186 int id = equeue_post(&q, no_func, e);
be_bryan 0:b74591d5ab33 187 prof_stop();
be_bryan 0:b74591d5ab33 188
be_bryan 0:b74591d5ab33 189 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 190 }
be_bryan 0:b74591d5ab33 191
be_bryan 0:b74591d5ab33 192 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 193 }
be_bryan 0:b74591d5ab33 194
be_bryan 0:b74591d5ab33 195 void equeue_post_many_prof(int count) {
be_bryan 0:b74591d5ab33 196 struct equeue q;
be_bryan 0:b74591d5ab33 197 equeue_create(&q, count*EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 198
be_bryan 0:b74591d5ab33 199 for (int i = 0; i < count-1; i++) {
be_bryan 0:b74591d5ab33 200 equeue_call(&q, no_func, 0);
be_bryan 0:b74591d5ab33 201 }
be_bryan 0:b74591d5ab33 202
be_bryan 0:b74591d5ab33 203 prof_loop() {
be_bryan 0:b74591d5ab33 204 void *e = equeue_alloc(&q, 0);
be_bryan 0:b74591d5ab33 205
be_bryan 0:b74591d5ab33 206 prof_start();
be_bryan 0:b74591d5ab33 207 int id = equeue_post(&q, no_func, e);
be_bryan 0:b74591d5ab33 208 prof_stop();
be_bryan 0:b74591d5ab33 209
be_bryan 0:b74591d5ab33 210 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 211 }
be_bryan 0:b74591d5ab33 212
be_bryan 0:b74591d5ab33 213 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 214 }
be_bryan 0:b74591d5ab33 215
be_bryan 0:b74591d5ab33 216 void equeue_post_future_prof(void) {
be_bryan 0:b74591d5ab33 217 struct equeue q;
be_bryan 0:b74591d5ab33 218 equeue_create(&q, EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 219
be_bryan 0:b74591d5ab33 220 prof_loop() {
be_bryan 0:b74591d5ab33 221 void *e = equeue_alloc(&q, 0);
be_bryan 0:b74591d5ab33 222 equeue_event_delay(e, 1000);
be_bryan 0:b74591d5ab33 223
be_bryan 0:b74591d5ab33 224 prof_start();
be_bryan 0:b74591d5ab33 225 int id = equeue_post(&q, no_func, e);
be_bryan 0:b74591d5ab33 226 prof_stop();
be_bryan 0:b74591d5ab33 227
be_bryan 0:b74591d5ab33 228 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 229 }
be_bryan 0:b74591d5ab33 230
be_bryan 0:b74591d5ab33 231 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 232 }
be_bryan 0:b74591d5ab33 233
be_bryan 0:b74591d5ab33 234 void equeue_post_future_many_prof(int count) {
be_bryan 0:b74591d5ab33 235 struct equeue q;
be_bryan 0:b74591d5ab33 236 equeue_create(&q, count*EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 237
be_bryan 0:b74591d5ab33 238 for (int i = 0; i < count-1; i++) {
be_bryan 0:b74591d5ab33 239 equeue_call(&q, no_func, 0);
be_bryan 0:b74591d5ab33 240 }
be_bryan 0:b74591d5ab33 241
be_bryan 0:b74591d5ab33 242 prof_loop() {
be_bryan 0:b74591d5ab33 243 void *e = equeue_alloc(&q, 0);
be_bryan 0:b74591d5ab33 244 equeue_event_delay(e, 1000);
be_bryan 0:b74591d5ab33 245
be_bryan 0:b74591d5ab33 246 prof_start();
be_bryan 0:b74591d5ab33 247 int id = equeue_post(&q, no_func, e);
be_bryan 0:b74591d5ab33 248 prof_stop();
be_bryan 0:b74591d5ab33 249
be_bryan 0:b74591d5ab33 250 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 251 }
be_bryan 0:b74591d5ab33 252
be_bryan 0:b74591d5ab33 253 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 254 }
be_bryan 0:b74591d5ab33 255
be_bryan 0:b74591d5ab33 256 void equeue_dispatch_prof(void) {
be_bryan 0:b74591d5ab33 257 struct equeue q;
be_bryan 0:b74591d5ab33 258 equeue_create(&q, EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 259
be_bryan 0:b74591d5ab33 260 prof_loop() {
be_bryan 0:b74591d5ab33 261 equeue_call(&q, no_func, 0);
be_bryan 0:b74591d5ab33 262
be_bryan 0:b74591d5ab33 263 prof_start();
be_bryan 0:b74591d5ab33 264 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 265 prof_stop();
be_bryan 0:b74591d5ab33 266 }
be_bryan 0:b74591d5ab33 267
be_bryan 0:b74591d5ab33 268 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 269 }
be_bryan 0:b74591d5ab33 270
be_bryan 0:b74591d5ab33 271 void equeue_dispatch_many_prof(int count) {
be_bryan 0:b74591d5ab33 272 struct equeue q;
be_bryan 0:b74591d5ab33 273 equeue_create(&q, count*EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 274
be_bryan 0:b74591d5ab33 275 prof_loop() {
be_bryan 0:b74591d5ab33 276 for (int i = 0; i < count; i++) {
be_bryan 0:b74591d5ab33 277 equeue_call(&q, no_func, 0);
be_bryan 0:b74591d5ab33 278 }
be_bryan 0:b74591d5ab33 279
be_bryan 0:b74591d5ab33 280 prof_start();
be_bryan 0:b74591d5ab33 281 equeue_dispatch(&q, 0);
be_bryan 0:b74591d5ab33 282 prof_stop();
be_bryan 0:b74591d5ab33 283 }
be_bryan 0:b74591d5ab33 284
be_bryan 0:b74591d5ab33 285 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 286 }
be_bryan 0:b74591d5ab33 287
be_bryan 0:b74591d5ab33 288 void equeue_cancel_prof(void) {
be_bryan 0:b74591d5ab33 289 struct equeue q;
be_bryan 0:b74591d5ab33 290 equeue_create(&q, EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 291
be_bryan 0:b74591d5ab33 292 prof_loop() {
be_bryan 0:b74591d5ab33 293 int id = equeue_call(&q, no_func, 0);
be_bryan 0:b74591d5ab33 294
be_bryan 0:b74591d5ab33 295 prof_start();
be_bryan 0:b74591d5ab33 296 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 297 prof_stop();
be_bryan 0:b74591d5ab33 298 }
be_bryan 0:b74591d5ab33 299
be_bryan 0:b74591d5ab33 300 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 301 }
be_bryan 0:b74591d5ab33 302
be_bryan 0:b74591d5ab33 303 void equeue_cancel_many_prof(int count) {
be_bryan 0:b74591d5ab33 304 struct equeue q;
be_bryan 0:b74591d5ab33 305 equeue_create(&q, count*EQUEUE_EVENT_SIZE);
be_bryan 0:b74591d5ab33 306
be_bryan 0:b74591d5ab33 307 for (int i = 0; i < count-1; i++) {
be_bryan 0:b74591d5ab33 308 equeue_call(&q, no_func, 0);
be_bryan 0:b74591d5ab33 309 }
be_bryan 0:b74591d5ab33 310
be_bryan 0:b74591d5ab33 311 prof_loop() {
be_bryan 0:b74591d5ab33 312 int id = equeue_call(&q, no_func, 0);
be_bryan 0:b74591d5ab33 313
be_bryan 0:b74591d5ab33 314 prof_start();
be_bryan 0:b74591d5ab33 315 equeue_cancel(&q, id);
be_bryan 0:b74591d5ab33 316 prof_stop();
be_bryan 0:b74591d5ab33 317 }
be_bryan 0:b74591d5ab33 318
be_bryan 0:b74591d5ab33 319 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 320 }
be_bryan 0:b74591d5ab33 321
be_bryan 0:b74591d5ab33 322 void equeue_alloc_size_prof(void) {
be_bryan 0:b74591d5ab33 323 size_t size = 32*EQUEUE_EVENT_SIZE;
be_bryan 0:b74591d5ab33 324
be_bryan 0:b74591d5ab33 325 struct equeue q;
be_bryan 0:b74591d5ab33 326 equeue_create(&q, size);
be_bryan 0:b74591d5ab33 327 equeue_alloc(&q, 0);
be_bryan 0:b74591d5ab33 328
be_bryan 0:b74591d5ab33 329 prof_result(size - q.slab.size, "bytes");
be_bryan 0:b74591d5ab33 330
be_bryan 0:b74591d5ab33 331 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 332 }
be_bryan 0:b74591d5ab33 333
be_bryan 0:b74591d5ab33 334 void equeue_alloc_many_size_prof(int count) {
be_bryan 0:b74591d5ab33 335 size_t size = count*EQUEUE_EVENT_SIZE;
be_bryan 0:b74591d5ab33 336
be_bryan 0:b74591d5ab33 337 struct equeue q;
be_bryan 0:b74591d5ab33 338 equeue_create(&q, size);
be_bryan 0:b74591d5ab33 339
be_bryan 0:b74591d5ab33 340 for (int i = 0; i < count; i++) {
be_bryan 0:b74591d5ab33 341 equeue_alloc(&q, (i % 4) * sizeof(int));
be_bryan 0:b74591d5ab33 342 }
be_bryan 0:b74591d5ab33 343
be_bryan 0:b74591d5ab33 344 prof_result(size - q.slab.size, "bytes");
be_bryan 0:b74591d5ab33 345
be_bryan 0:b74591d5ab33 346 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 347 }
be_bryan 0:b74591d5ab33 348
be_bryan 0:b74591d5ab33 349 void equeue_alloc_fragmented_size_prof(int count) {
be_bryan 0:b74591d5ab33 350 size_t size = count*EQUEUE_EVENT_SIZE;
be_bryan 0:b74591d5ab33 351
be_bryan 0:b74591d5ab33 352 struct equeue q;
be_bryan 0:b74591d5ab33 353 equeue_create(&q, size);
be_bryan 0:b74591d5ab33 354
be_bryan 0:b74591d5ab33 355 void *es[count];
be_bryan 0:b74591d5ab33 356
be_bryan 0:b74591d5ab33 357 for (int i = 0; i < count; i++) {
be_bryan 0:b74591d5ab33 358 es[i] = equeue_alloc(&q, (i % 4) * sizeof(int));
be_bryan 0:b74591d5ab33 359 }
be_bryan 0:b74591d5ab33 360
be_bryan 0:b74591d5ab33 361 for (int i = 0; i < count; i++) {
be_bryan 0:b74591d5ab33 362 equeue_dealloc(&q, es[i]);
be_bryan 0:b74591d5ab33 363 }
be_bryan 0:b74591d5ab33 364
be_bryan 0:b74591d5ab33 365 for (int i = count-1; i >= 0; i--) {
be_bryan 0:b74591d5ab33 366 es[i] = equeue_alloc(&q, (i % 4) * sizeof(int));
be_bryan 0:b74591d5ab33 367 }
be_bryan 0:b74591d5ab33 368
be_bryan 0:b74591d5ab33 369 for (int i = count-1; i >= 0; i--) {
be_bryan 0:b74591d5ab33 370 equeue_dealloc(&q, es[i]);
be_bryan 0:b74591d5ab33 371 }
be_bryan 0:b74591d5ab33 372
be_bryan 0:b74591d5ab33 373 for (int i = 0; i < count; i++) {
be_bryan 0:b74591d5ab33 374 equeue_alloc(&q, (i % 4) * sizeof(int));
be_bryan 0:b74591d5ab33 375 }
be_bryan 0:b74591d5ab33 376
be_bryan 0:b74591d5ab33 377 prof_result(size - q.slab.size, "bytes");
be_bryan 0:b74591d5ab33 378
be_bryan 0:b74591d5ab33 379 equeue_destroy(&q);
be_bryan 0:b74591d5ab33 380 }
be_bryan 0:b74591d5ab33 381
be_bryan 0:b74591d5ab33 382
be_bryan 0:b74591d5ab33 383 // Entry point
be_bryan 0:b74591d5ab33 384 int main() {
be_bryan 0:b74591d5ab33 385 printf("beginning profiling...\n");
be_bryan 0:b74591d5ab33 386
be_bryan 0:b74591d5ab33 387 prof_baseline(baseline_prof);
be_bryan 0:b74591d5ab33 388
be_bryan 0:b74591d5ab33 389 prof_measure(equeue_tick_prof);
be_bryan 0:b74591d5ab33 390 prof_measure(equeue_alloc_prof);
be_bryan 0:b74591d5ab33 391 prof_measure(equeue_post_prof);
be_bryan 0:b74591d5ab33 392 prof_measure(equeue_post_future_prof);
be_bryan 0:b74591d5ab33 393 prof_measure(equeue_dispatch_prof);
be_bryan 0:b74591d5ab33 394 prof_measure(equeue_cancel_prof);
be_bryan 0:b74591d5ab33 395
be_bryan 0:b74591d5ab33 396 prof_measure(equeue_alloc_many_prof, 1000);
be_bryan 0:b74591d5ab33 397 prof_measure(equeue_post_many_prof, 1000);
be_bryan 0:b74591d5ab33 398 prof_measure(equeue_post_future_many_prof, 1000);
be_bryan 0:b74591d5ab33 399 prof_measure(equeue_dispatch_many_prof, 100);
be_bryan 0:b74591d5ab33 400 prof_measure(equeue_cancel_many_prof, 100);
be_bryan 0:b74591d5ab33 401
be_bryan 0:b74591d5ab33 402 prof_measure(equeue_alloc_size_prof);
be_bryan 0:b74591d5ab33 403 prof_measure(equeue_alloc_many_size_prof, 1000);
be_bryan 0:b74591d5ab33 404 prof_measure(equeue_alloc_fragmented_size_prof, 1000);
be_bryan 0:b74591d5ab33 405
be_bryan 0:b74591d5ab33 406 printf("done!\n");
be_bryan 0:b74591d5ab33 407 }