2.1 Obtaining aprof

2.2 Setting up optional tools

For using aprof, a Linux or Windows installation is required. For Windows, Cygwin is suggested (optional) in order to significantly ease the use of aprof.

In any case, standard Unix/Linux tools are expected:

• bash
• make
• patch
• gawk

Boehm's garbage collector is also required, but is included both in source and compiled form (binary releases only) within the /thirdparty subdirectory.

For Windows:

• Go to http://sources.redhat.com/cygwin/
• Download the automated web installer (setup.exe)
• Copy it to an empty local directory (e.g. C:\temp\cygwin)
• Click setup.exe
• Select Install from the Internet. Make sure to select make since it might be disabled in the preselection.

Cygwin will then be setup in the C:\cygwin directory of your Windows OS.

For Linux:

• Any recent Linux distribution should do; try using Ubuntu 11.10.

2.3 aprof setup

There is no actual installation procedure; the user should just unzip the aprof-[lin|win]-yymmdd.tar.bz2 binary release archive to a local directory. Usual choices include C:/cygwin/home/user for Windows (no Cygwin) users and /home/user for Windows Cygwin/Linux users where user is the name of the current user.

Then, change directory to /home/user/aprof. On Cygwin for instance, type:

Set up the APROFTOP environmental variable:

The location of the garbage collector is adjusted accordingly in the corresponding makefiles.

You may add the /aprof/bin directory to your path:

2.4. Building from sources

This subsection is relevant only to the source releases of aprof (aprof-src-yymmdd.tar.bz2). To build aprof from sources the following are required:

1. For Linux users:

• A typical Linux installation (bash, make, gawk)
• The TXL compiler from http://www.txl.ca (e.g. version 10.6)
• In case you want to use your system's gc, change GCPATH in /src/Makefile.linux accordingly. Then run the build script from the top-level subdirectory:

• If you want to recompile gc, use the build-a.sh script. The script should be changed accordingly (comment and uncommented certain lines) for selecting either gc6.8 or gc-7.2alpha6 or for enabling a Windows Cygwin or a Linux build.

2. For Windows users:

• Windows XP SP2 or older (untested on newer systems).
• Cygwin environment (bash, make, gawk). Cygwin can be installed via an automated web installer (setup.exe) from http://sources.redhat.com/cygwin/
• TXL installation for Cygwin.
• Run the build script from the top-level subdirectory of aprof:

• Similarly to the Windows case, for rebuilding gc, use the following:

4.1 nac2c usage

The basic usage of nac2c follows the syntax:

The translated C representation of input.nac is produced in a series of output files called input<i>_nac.c, separately for each NAC-level procedure, where input<i> is the name of the corresponding procedure. Pre-existing files are overwritten.

options` is one or more of the following:

-d

Enable debug output.

-force-data-types

Force predefined data types as given in NAC code. Essentially disables the effect of both interval analysis and the alternative of using the unknown data type na.

-ssa

Internal construction of SSA (Static Single Assignment) form.

-pseudo-ssa

Internal construction of local SSA-like form.

-use-aycockhorspool

Enables SSA construction using the Aycock-Horspool algorithm.

-keep-ssa

Does not perform out-of-SSA conversion and thus keeps PHI statements in the generated CDFGs.

-phi-bbs

Enable the generation of BB arguments in phi NAC statements.

-no-phi-bbs

Disable the generation of BB arguments in phi statements (default).

-emit-ansic

Emit the equivalent ANSI C program after processing (including SSA conversion, if enabled).

-emit-cdfg

Generate the Graphviz representations for all procedure CDFGs.

-emit-cfg

Generate the Graphviz representations for all procedure CFGs.

-emit-cg

Generate the Graphviz representation of the application call graph.

-gcc

Generate Makefile for GCC compilation (default).

-llvm

Generate Makefile for LLVM compilation and/or interpretation.

4.2 fixnac usage

The basic usage of fixnac follows the syntax:

Additional fixes are applied to the instrumented input.nac such as the additon of the declaration of the globalvar BB array for storing BB execution frequencies.

options` is one or more of the following:

-h

Print this help.

-decl-bb-array

Declare the _BB globalvar.

-init-bb-array

Initialize the _BB globalvar to zeros. Only in the effect if -decl-bb-array has been defined.

-max-bbs <num>

Specify the maximum number of basic blocks in a program. Default: 10000.

4.3 meascycles usage

The basic usage of meascycles follows the syntax:

It reads the input.nac which is assumed to be uninstrumented, the input_prof.txt profiling report file and the corresponding input_sched.txt scheduling data file. Then it reports the total number of dynamic abstract machine cycles in the following form:

as a C-based long long int (64-bit signed integer).

4.4 TXL passes

Executables generated by TXL passes source files share a common invocation style:

This scheme applies for executables nacbbinscounters, nacparser and nactoglobal.

4.5 countbbs.awk usage

This AWK script generates a textual report named bbs.txt that stores the total number of basic blocks in the given NAC translation unit. countbbs is invoked as follows:

6.1 Generation of the reference test data

Assuming that gcc is used as the host machine compiler, the following prompt generates the corresponding executable:

Then, the reference data can be generated:

The contents of fact_test_data.txt are input and output values for n and y=fact(n) in hexadecimal form:

00000000 00000001
00000001 00000001
00000002 00000002
00000003 00000006
00000004 00000018
00000005 00000078
00000006 000002d0
00000007 000013b0
00000008 00009d80
00000009 00058980
0000000a 00375f00
0000000b 02611500
0000000c 1c8cfc00
0000000d 7328cc00

6.2 Create a working copy of the NAC representation of fact

This can be accomplished by copying fact.0.nac to fact.nac:

6.3 Tracking the number of basic blocks in the unit

The following bash script variable

is used for maintaining the number of basic blocks in the NAC translation unit.

6.4 Generate the bbs.txt file

An AWK script, countbbs.awk is used for counting the basic blocks in the entire translation unit. This is performed by enumerating the labels in the NAC program, since all NAC basic blocks have explicit labels:

Then, the bbs.txt file is processed, to get the number of basic blocks:

# Process the bbs.txt file.
bbsfile="bbs.txt"
while read -r bbs;
do
  num_bbs="${bbs}"
done < ${bbsfile}

A while loop is used, in order to extract all the basic block counts in bbs.txt in case of a multi-translation unit application (currently unsupported by most features of aprof).

6.5 Instrumentation of the NAC file

The nacinsbbcount TXL pass inserts profiling code for dynamic basic block counting in NAC programs:

A usual setup for TXL options is:

Then, fixnac is invoked for adding bookkeeping code as for the declaration of the _BB global array, its initialization and specifying the maximum number of basic blocks in the program.

The resulting fact.nac representation is as follows:

globalvar u64 _BB[4]={0,0,0,0};
procedure fact(in s32 n,out s32 y)
{
  localvar s32 res;
  localvar s32 x;
  localvar s32 i;
  localvar u32 _temp_addr;
  localvar u32 _temp_data;
L0005:
  _temp_addr <= ldc 0;
  _temp_data <= load _BB,_temp_addr;
  _temp_data <= add _temp_data,1;
  _BB <= store _temp_data,_temp_addr;
  x <= mov n;
  res <= ldc 1;
  i <= ldc 1;
  D_1363 <= jmpun;
D_1362:
  _temp_addr <= ldc 1;
  _temp_data <= load _BB,_temp_addr;
  _temp_data <= add _temp_data,1;
  _BB <= store _temp_data,_temp_addr;
  res <= mul res,i;
  i <= add i,1;
  D_1363 <= jmpun;
D_1363:
  _temp_addr <= ldc 2;
  _temp_data <= load _BB,_temp_addr;
  _temp_data <= add _temp_data,1;
  _BB <= store _temp_data,_temp_addr;
  D_1362,D_1364 <= jmple i,x;
D_1364:
  _temp_addr <= ldc 3;
  _temp_data <= load _BB,_temp_addr;
  _temp_data <= add _temp_data,1;
  _BB <= store _temp_data,_temp_addr;
  y <= mov res;
}

6.6 Generation of the backend C files for the given NAC t.u.

The profiling process is based on the generation of a compiled simulator for the NAC program. This is accomplished with the use of the nac2c decompiler which is applied on the original form of the application (fact.0.nac). This is needed in order to extract the static schedule of the initial form of the application.

Either the sequential or the ASAP scheduler can be used, which correspondingly reflect a sequential or intra-block parallel abstract machine.

First, a static scheduling extraction run of nac2c must be performed.

For enabling the sequential scheduler the following should be used:

The ASAP scheduler is enabled as follows, since it mandates at least pseudo-SSA (Static-Single Assignment):

Then, nac2c generates a multitude of files, which have been detailed in Section 5.

A file named fact_sched.txt is expected to be passed to a second run of aprof, which is the profiling run:

fact.sched.txt contains the estimated static cycles per basic block:

5
4
2
2

aprof proceeds with the second run of nac2c:

6.7 Optional step for generating CDFG views

Optionally, the Graphviz (*.dot) representation of each NAC procedure can be visualized using the following snippet:

procfile="procedure_names.txt"
while read -r app2;
do
  echo "Creating CDFG view for ${app2}"
  dot -Tpng -O ${app2}.dot
done < ${procfile}

6.8 Building and running the compiled simulator

In this step, the ansic.mk generated Makefile must be run in order to build main.exe, which is the compiled simulator for the examined application, fact.

This run produces fact_prof.txt which contains dynamic basic block counts:

14
91
105
14

6.9 Calculation of dynamic abstract machine cycles

Finally, meascycles is used for combining the dynamic basic block counts written in fact_prof.txt with the static cycle estimates which are found in fact_sched.txt:

As a result, the profiling estimate is produced in the standard output. For instance, the sequential scheduler produces:

while the ASAP scheduler computes the following: