trafgen.h File Reference

Routines used by the Flowgrind daemon for advanced traffic generation. More...

#include "config.h"

Go to the source code of this file.

Functions
double	next_interpacket_gap (struct flow *)
int	next_request_block_size (struct flow *)
int	next_response_block_size (struct flow *)

Detailed Description

Routines used by the Flowgrind daemon for advanced traffic generation.

Definition in file trafgen.h.

Function Documentation

next_interpacket_gap()

double next_interpacket_gap

(

struct flow *

)

Definition at line 173 of file trafgen.c.

                                               {
 
        double gap = 0.0;
        if (flow->settings.write_rate)
                gap = ((double)flow->settings.maximum_block_size)/flow->settings.write_rate;
        else
                gap = calculate(flow,
                                flow->settings.interpacket_gap_trafgen_options.distribution,
                                       flow->settings.interpacket_gap_trafgen_options.param_one,
                                       flow->settings.interpacket_gap_trafgen_options.param_two
                                      );
 
        if (gap)
                DEBUG_MSG(LOG_NOTICE, "calculated next interpacket gap %.6fs "
                          "for flow %d", gap, flow->id);
 
        return gap;
}

next_request_block_size()

int next_request_block_size

(

struct flow *

)

Definition at line 107 of file trafgen.c.

{
        int bs = 0;
        int i = 0;
        /* recalculate values to match prequisits, but at most 10 times */
        while (( bs < MIN_BLOCK_SIZE || bs > flow->settings.maximum_block_size) && i < MAX_RUNS_PER_DISTRIBUTION) {
 
                bs = round(calculate(
                           flow,
                           flow->settings.request_trafgen_options.distribution,
                           flow->settings.request_trafgen_options.param_one,
                           flow->settings.request_trafgen_options.param_two
                           ));
                i++;
        }
 
        /* sanity checks */
        if (i >= MAX_RUNS_PER_DISTRIBUTION && bs < MIN_BLOCK_SIZE) {
                bs = MIN_BLOCK_SIZE;
                DEBUG_MSG(LOG_WARNING, "applied minimal request size limit %d "
                          "for flow %d", bs, flow->id);
        }
 
        if (i >= MAX_RUNS_PER_DISTRIBUTION && bs > flow->settings.maximum_block_size) {
                bs = flow->settings.maximum_block_size;
                DEBUG_MSG(LOG_WARNING, "applied maximal request size limit %d "
                          "for flow %d", bs, flow->id);
 
        }
 
        DEBUG_MSG(LOG_NOTICE, "calculated request size %d for flow %d after %d "
                  "runs", bs, flow->id, i);
 
        return bs;
}

next_response_block_size()

int next_response_block_size

(

struct flow *

)

Definition at line 143 of file trafgen.c.

{
        int bs = round(calculate(
                           flow,
                           flow->settings.response_trafgen_options.distribution,
                           flow->settings.response_trafgen_options.param_one,
                           flow->settings.response_trafgen_options.param_two
                           ));
 
        /* sanity checks */
        if (bs && bs < MIN_BLOCK_SIZE) {
                bs = MIN_BLOCK_SIZE;
                DEBUG_MSG(LOG_WARNING, "applied minimal response size limit "
                          "%d for flow %d", bs, flow->id);
        }
        if (bs > flow->settings.maximum_block_size) {
                bs = flow->settings.maximum_block_size;
                DEBUG_MSG(LOG_WARNING, "applied maximal response size limit "
                          "%d for flow %d", bs, flow->id);
 
        }
 
        if (bs)
                DEBUG_MSG(LOG_NOTICE, "calculated response size %d for flow "
                          "%d", bs, flow->id);
 
        return bs;
 
}