Generator of Self-Similar Network Traffic (version 2)

This file contains description of a trace generating utility. Refer to description of version 1 for more information

Distribution list

1. _types.h
2. _link.h
3. _util.h
4. _rand_MT.h
5. trace.h
6. source.h
7. aggreg.h
8. MersenneTwister.h

What is new

1. Mersenne Twister random number generator designed by Makoto Matsumoto and Takuji Nishimura was used instead of built-in rand() function. We used Mersenne Twister RNG implemented as C++ class by Rick Wagner. Generating random values using MTrand class is much faster than using rand() built-in function. Additionally, it generates 32bit random values, while rand() return 16 bit numbers. That greatly reduced effects of tail truncation in a generated Pareto series.
   
2. Source constructor is modified to accept the following parameters

   
   
       SourcePareto(   int16u id,          // 16-bit source id
                       int16u prior,       // priority assignemnt for all the packets generated by that source
                       pct_size_t pct_sz,  // packet size 
                       pct_size_t ipgap,   // inter-packet gap (including the preamble)
                       DOUBLE load,        // load offered by the source
                       DOUBLE on_shape,    // shape parameter for the distribution of sizes of ON periods
                       DOUBLE off_shape    // shape parameter for the distribution of sizes of OFF periods
                   )
   
   

   The minimum OFF period (location parameter for the OFF periods) was removed from the argument list because it is a secondary parameter dependent on load. Given a desired load, the minimum gap is calculated by the SourcePareto constructor automatically.

The following are public methods of class Generator

    Generator(void);                    // Class constructor does not accept any arguments

    void    Reset( void );              // resets all statistic variables and elapsed time
                                        // Reset should be called to generate multiple traces 
                                        // with same set of sources 

    void    AddSource( Source* );       // add a new source to the generator

    void    RemoveSource( Source* p );  // removes source pointed to by p
    Source* RemoveSource( void );       // removes first source from the (internal)list

    void    SetLoad( DOUBLE newload );  // sets total node load (all N sources are to have 
                                        // equal load of newload/N)	
  
    Trace   PeekNextPacket(void);       // peeks at next packet before it arrives
    Trace   GetNextPacket(void);        // returns the next packet from the aggregated traffic

The following is a simple function that creates an instance of generator and generates (prints out) 1 mln. traces obtained by aggregating 128 sources of ON/OFF periods with cumulative load of 30%.

void main( void )
{

    int    sources = 128;
    double load    = 0.3;
    long   traces  = 1000000;

    Generator AG;

    // add sources
    for( int src = 0; src < sources; src++ )
        AG.AddSource( new SourcePareto( src, 0, packet_size(), 9, load / sources, 1.4, 1.2 ));
    
    // output traces
    while( traces-- > 0 )
	cout << AG.GetNextPacket();

    // delete sources
    for( Source* psrc = AG.RemoveSource(); psrc; psrc = AG.RemoveSource())
	delete psrc;
    
}

To verify the correctness of the traffic generator we plotted a Variance-Time log-log plot. We used shape parameter for the ON periods α = 1.4. The choice of α was prompted by measurements on actual Ethernet traffic performed by Leland et al. [1]. They reported the measured Hurst parameter of 0.8 for moderate network load. The relationship between the Hurst parameter and the shape parameter α is H = (3 - α)/2 (see [2]). Thus, α = 1.4 should result in H = 0.8.

Figure above shows a variance-time log-log plot. We ran the generator with n = 32, 128, 512, and 2048 sources. The plot shows linear dependency with slope s = –0.4. The slope is related to Hurst parameter as s = 2H – 2. That results in H = 1 + s/2 = 0.8, as expected.

Reader is referred to [3] for an introduction to the concepts of self-similarity and long-range dependence.

4-4-2001