view release on metacpan or  search on metacpan

src/apachebench/execute.c  view on Meta::CPAN

#include <sys/time.h>
#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>

#include "types.h"
#include "execute.h"

/* ------------------------------------------------------- */

void
initialize(struct global * registry) {
    int i,j;

#ifdef AB_DEBUG
    printf("AB_DEBUG: start of initialize()\n");
#endif

    registry->cookie = malloc(registry->number_of_runs * sizeof(char *));
    registry->buffersize = malloc(registry->number_of_runs * sizeof(int));
    registry->auto_cookies = (char ***) calloc(registry->number_of_runs, sizeof(char **)); // must be zeroed for the calloc code in http_util.c

    registry->which_thread = malloc(registry->number_of_urls * sizeof(int *));
    registry->arranged = malloc(registry->number_of_urls * sizeof(int));

    for (i = 0; i < registry->number_of_urls; i++)
        registry->arranged[i] = 0;
    for (i = 0; i < registry->number_of_runs; i++) {
        for (j = registry->position[i]; j < registry->position[i+1]; j++)
            registry->which_thread[j] = malloc(registry->repeats[i] * sizeof(int));
        for (j = 0; j < registry->repeats[i]; j++)
            registry->which_thread[registry->position[i]][j] = j;
        registry->need_to_be_done += registry->repeats[i] * (registry->position[i+1] - registry->position[i]);
    }
    registry->ready_to_run_queue = malloc(registry->need_to_be_done * sizeof(struct threadval));
    for (i = 0; i < registry->number_of_runs; i++) {
        if (registry->order[i] == DEPTH_FIRST) {
            if ((registry->priority == EQUAL_OPPORTUNITY) || (registry->tail < registry->concurrency)) {
                registry->arranged[registry->position[i]] = 1;
                registry->ready_to_run_queue[registry->tail].run = i;
                registry->ready_to_run_queue[registry->tail].url = registry->position[i];
                registry->ready_to_run_queue[registry->tail++].thread = 0;
            }
        } else for (j = 0; j < registry->repeats[i]; j++)
            if ((registry->priority == EQUAL_OPPORTUNITY) || (registry->tail < registry->concurrency)) {
                registry->arranged[registry->position[i]] += 1;
                registry->ready_to_run_queue[registry->tail].run = i;
                registry->ready_to_run_queue[registry->tail].thread = j;
                registry->ready_to_run_queue[registry->tail++].url = registry->position[i];
            }
    }
    registry->hostname = malloc(registry->number_of_urls * sizeof(char *));
    registry->path = malloc(registry->number_of_urls * sizeof(char *));
    registry->port = malloc(registry->number_of_urls * sizeof(int));
    registry->ctypes = malloc(registry->number_of_urls * sizeof(char *));
    registry->req_headers = malloc(registry->number_of_urls * sizeof(char *));
    registry->keepalive = malloc(registry->number_of_urls * sizeof(bool));
    registry->url_tlimit = malloc(registry->number_of_urls * sizeof(double));
    registry->started = malloc(registry->number_of_urls * sizeof(int));
    registry->finished = malloc(registry->number_of_urls * sizeof(int));
    registry->failed = malloc(registry->number_of_urls * sizeof(int));
    registry->good = malloc(registry->number_of_urls * sizeof(int));
    registry->postdata = malloc(registry->number_of_urls * sizeof(char *));
    registry->postsubs = malloc(registry->number_of_urls * sizeof(SV *));
    registry->postlen = malloc(registry->number_of_urls * sizeof(int));
    registry->posting = malloc(registry->number_of_urls * sizeof(int));
    registry->totalposted = malloc(registry->number_of_urls * sizeof(int));
    for (i = 0; i < registry->number_of_urls; i++) {
        registry->totalposted[i] = 0;
        registry->port[i] = 80;        /* default port number */
        registry->started[i] = 0;
        registry->finished[i] = 0;
        registry->failed[i] = 0;
        registry->good[i] = 0;
    }
#ifdef AB_DEBUG
    printf("AB_DEBUG: end of initialize()\n");
#endif
}

/* --------------------------------------------------------- */

/* run the tests */

static void
test(struct global * registry) {
    struct timeval timeout, now;
    fd_set sel_read, sel_except, sel_write;
    int i;

    registry->con = calloc(registry->concurrency, sizeof(struct connection));
    memset(registry->con, 0, registry->concurrency * sizeof(struct connection));

#ifdef AB_DEBUG
    printf("AB_DEBUG: start of test()\n");
#endif

    for (i = 0; i < registry->concurrency; i++) {
        registry->con[i].url = registry->ready_to_run_queue[i].url;
        registry->con[i].run = registry->ready_to_run_queue[i].run;
        registry->con[i].state = STATE_READY;
        registry->con[i].thread = registry->ready_to_run_queue[i].thread;
    }

#ifdef AB_DEBUG
    printf("AB_DEBUG: test() - stage 1\n");
#endif

    registry->stats = calloc(registry->number_of_urls, sizeof(struct data *));
    for (i = 0; i < registry->number_of_runs; i++) {
        int j;
        for (j = registry->position[i]; j < registry->position[i+1]; j++)
            registry->stats[j] = calloc(registry->repeats[i], sizeof(struct data));
    }

#ifdef AB_DEBUG
    printf("AB_DEBUG: test() - stage 2\n");