Man page for micro

Man page for micro_mem

Manual page for micro_mem


MICRO_MEM(1)            USER COMMANDS            MICRO_MEM(1)

                                            Table of Contents

NAME

micro_mem - Multiprocessor Memory Hierarchy and Network Interconnect Micro Benchmark - Version 0.3, Oct 1994

SYNOPSIS

micro_mem procs [ -A arraysize ] [ -L lower ] [ -U upper ] [ -I iterations ] [ -P exec_procs ] [ -H init_procs ] [ -d ] [ -a ] [ -f filename ]

DESCRIPTON

micro_mem is used to obtain the physical and performance profiles of the memory hierarchy and network interconnect of shared-memory multiprocessors.

USE

The only required argument by micro_mem is the number of threads. Consider the example :

       micro_mem 4

Here four threads are used to measure the average time require to read, modify and write a single element of a double floating point array over different values of size, and stride. Variable size ranges from lower (default 1) to upper (default 2^20) elements. For each particular value of size, stride is varied from 1 to size / 2. Each thread starts each experiment at position first_elem = (arraysize * thread_id / procs), where thread_id is the logical id number of the thread. If (first_elem + size) is larger than arraysize the thread wraps around element 0. The following figure illustrates the accesses made by each thread when size = (arraysize / 4), stride = 1 :


             0000000000111111111122222222223333333333
             0123456789012345678901234567890123456789
             <------------- arraysize -------------->
    thread-0 <------ size ------>
    thread-1           <------------------>
    thread-2                     <------------------>
    thread-3 <-------->                    <-------->

When size is less than arraysize / procs, there is no data contention amongst the threads. The maximum amount of contention occurs when size = arraysize and stride = (size / 2). File Super_93_1.ps, which is included in the distribution, explains in more detail how the micro benchmark is used to explore the performance space.

OPTIONS

(Several of the following options take as an argument a restricted-number (a multiple of a power of two), which is given as n m, and represents number n*2^m.)

[ -A ] Set the maximum size of the array used in the experiments to arraysize. Arraysize is given as a restricted-number, e.g., -A 1 21, which represents 1*2^21 = 2 elems. If -L and -U are not set, the micro benchmark tests all values of size (restricted to powers of two) in the interval 1 <= size <= arraysize (default: -A 1 20 = 1 elems).
[ -L ] Set the smallest value for size to lower (default: -L 1 1).
[ -U ] Set the largest value for size to upper (default: use the value given to -A).
[ -I ] The number of total accesses in a single experiment (fixed size and stride). This argument can be used to control the total execution time of the benchmark. If iterations is smaller than upper, however, then some experiments accessing more array elements than the value of iterations will not be tested. For example, if -U 1 20 and -I 1 18, then experiments for sizes in the interval 1 <= size <= 1 elems and for strides in the interval 1 <= stride <= size / 2 will be tested, except for
```
              size            stride
            ---------        --------
            512 elems         1 elem
              1 elems         1 elem
              1 elems         2 elems    
```
[ -P ] During the actual experiments, use list exec_procs to map threads to physical processors. Once a thread is moved to a processor, it remains there until the bench- mark finishes. The processors uses in initializing the main array (init_procs) can be different from exec_procs. The number of elements in exec_procs should match the value of argument procs (default: -P 0 1 ... procs - 1).
[ -H ] During the initialization, use list init_procs to map threads to physical processors. Similar to -P, the number of elements in init_procs should match argument procs (default: -H same as -P).
[ -d ] Set verbose mode; instructs the program to print, as comments, relevant information about the experiments (default: no verbose mode).
[ -a ] Print time measurements taken only on thread 0 (default: all threads).
[ -f ] Read exec_procs and possible init_procs (see -h) from filename. This is equivalent to setting option -P.
[ -h ] When -f has been set, this flag is equivalent to set- ting -H, but list init_procs is read from filename. The first procs number are assigned to init_procs and the second set to exec_procs.

EXAMPLES

The following examples illustrate some interesting experiments:

1) To measure the performance characteristics of the memory hierarchy as seen from a particular processor (in this case 7):

      micro_mem 1 -P 7

2) To measure the effect of data contention on 8 processors (23 45 65 9 23 1 4 10) on an array of 4 MBytes (assuming 8 bytes per element):

      micro_mem 8 -A 1 19 -L 1 17 -P 23 45 65 9 23 1 4 10

3) To measure the effects of contention in the interconnect as a function of the number of threads, but under constant data contention (in this case only 2 procs content for the same element), we can run the following four configurations:

          micro_mem  2 -A 1 20 -L 1 20 -U 1 20
          micro_mem  4 -A 2 20 -L 1 20 -U 1 20
          micro_mem  8 -A 4 20 -L 1 20 -U 1 20
          micro_mem 10 -A 5 20 -L 1 20 -U 1 20
          micro_mem 12 -A 6 20 -L 1 20 -U 1 20
          micro_mem 14 -A 7 20 -L 1 20 -U 1 20
          micro_mem 16 -A 8 20 -L 1 20 -U 1 20

FILES

The micro benchmark consists of three modules: micro_mem.c, utils.c, and machine.c. The first two are machine- independent and do not require changes when porting them to a new system. Machine.c, on the other hand, is machine- dependent and contains critical functions for thread/process creation, synchronization, and memory allocation. Details about these functions are given in file machine.c. Currently, we support three different versions of machine.c: machine_ksr.c (KSR1 using POSIX primitives), machine_dash.C (Dash multiprocessor using ANL macros) and machine_uni.c (vanilla uniprocessor). For each version of machine_mach.c, where mach is a mnemonic identifying a particular machine, there is a file Makefile_mach that contains specific instructions about how to compile the sources.

BUGS

Argument HAS TO BE the first argument and is always required. If it is missing or in the wrong place, expect problems.

SEE ALSO (man pages not available) mm_filter(1), build_gnuplot(1).

Table of Contents

NAME
SYNOPSIS
DESCRIPTION
USE
OPTIONS
EXAMPLES
FILES
BUGS

Sun Release 4.1 Last change: Sept. 22, 1994 5

man page for micro_mem