KitFox: Multi-Physics Libraries

KitFox: Multi-Physics Libraries for Integrated Power, Thermal, and Reliability Simulations of Multicore Microarchitectures

KitFox (formerly known as Energy Introspector) is an integrated power, thermal, and lifetime reliability modeling framework. The goal of KitFox is to facilitate the microarchitectural exploration at the intersection of applications, microarchitectural performance, and various physical phenomena including energy, power, thermal, and lifetime reliability. KitFox is based on the integration of models that simulate different physical properties, including the popular tools in architecture community such as HotSpot or McPAT. Each model in KitFox is encapsulated into a standard class called libraries (e.g., energy, thermal, or reliability library). Any new or updated models can be seamlessly integrated into KitFox by encapsulating them into the respective library. There are no hidden software dependencies between the libraries, and all interactions are explicitly managed via a standard library interface that avoids modifications to the third-party tools. The interface to the multicore simulator is through an API that relieves the microarchitecture modeler from orchestrating all multi-physics interactions. Towards this goal, KitFox has the following features and contributions:

  • Standard library: Each model is encapsulated into standard class called library and integrated to KitFox. No cross-dependency in software integration is created between the models, and any new models can be added to the framework
  • Interacting library models: Interactions between the physical models are orchestrated inside KitFox via the standard library interface. It minimizes user involvement in data management to coordinate multiple libraries and subclass models.
  • Simple user API: KitFox provides a set of API functions to be used in microarchitecture simulations. The same function is used for calculating the same physical property via the standard library interface, regardless of which individual model is used inside the framework.
  • Configurable processor model: KitFox provides a configurable method that users can define the microarchitectural and physical hierarchy of a processor package and associate individual physical models with constituent processor components to be simulated.
  • Parallel simulation via MPI: KitFox supports the parallel simulation of physical models via the MPI. The microarchitecture simulator and KitFox can run in parallel in separate MPI processes, and KitFox itself can also be parallelized into multiple MPI ranks.

1. Download

1.1. Prerequisites

The following packages are required to be installed in the system in prior to building KitFox and supported modeling tools:


  • g++ v4.2 or later
  • open-mpi v1.4 or later (or mpich2)
  • libconfig++ v1.4 or later
  • bison v2.4.1 and flex for 3D-ICE
  • Linux or Mac OS X environment


1.2. Download

The latest stable version of KitFox can be downloaded from the following link: kitfox-v1.1.tar.gz

The latest development copy in progress can be obtained from the repository.
$ svn co

2. Documentation

Detailed description about the design methodology, implementation, and usage of KitFox is available in the document: kitfox-v1.0.0.pdf

The document is also included in the doc directory. The following command generates a pdf document doc/kitfox-v1.0.0.pdf:
$ make doc

One of the following publications can be used to cite KitFox:

author={William J. Song and Saibal Mukhopadhyay and Sudhakar Yalamanchili},
title={KitFox: multi-physics libraries for integrated power, thermal, and reliability simulations of multicore microarchitecture},
journal={IEEE Transactions on Component, Packaging, and Manufacturing Technology},

author={William J. Song and Saibal Mukhopadhyay and Sudhakar Yalamanchili},
title={Energy Introspector: A parallel, composable framework for integrated power-reliability-thermal modeling for multicore architectures},
booktitle={IEEE International Symposium on Performance Analysis of Systems and Software},

3. Build

3.1. Downloading Models

Note: KitFox does NOT possess the copyrights of the following supported models. All terms and conditions are subject to what original developers present. KitFox does not guarantee the correctness or identical performance as the original distributions of modeling tools.

We strongly recommend to acquire the models through developers’ distributions. Downloading the compatible version of each model is scripted in the Makefile via a wget command, but not all models are supported in this way due to developers’ distribution methods. The paths to obtain the models are listed below:



The tarball of each model has to be downloaded to the tarball directory of the corresponding model. For instance, download the compatible version of McPAT (mcpat0.8_r274.tar.gz) to library/energylib_mcpat/tarball/. Other models not listed above were developed with KitFox, and the developers agreed to distribute them along with KitFox. In each model, a patch file provides corrections to the model to solve compile errors due to the integration with other models and KitFox. These changes are not intended to alter the calculated results of the original version, but we do not guarantee the correctness or identical performance as the original distributions of modeling tools.

3.2. Compiling Models

At the main directory of KitFox, each model can be compiled individually via the following command:
$ make <model name>

For instance, make mcpat compiles the McPAT source files and creates an archive file libmcpat.a in the main directory. Model name has to be one of the following:
$ make dramsim
$ make dsent
$ make intsim
$ make mcpat
$ make tsv
$ make failure
$ make 3dice
$ make hotspot
$ make microfluidics

Alternatively, all models included in KitFox can be built by using the following command:
$ make models

3.3. Building KitFox

After all the models that are to be used are compiled, KitFox can be built using the following command:
$ make kitfox

This command creates an archive file libKitFox.a that has to be linked to the architecture simulator along with the archive files of built models (e.g., libmcpat.a). Note that only the compiled models create archive files and are compiled with KitFox.

There are two different ways to clean the KitFox files. The first command cleans the object and archive files of KitFox. Re-compiling KitFox requires only make kitfox command and does not need to re-build the models.
$ make clean

The second command completely cleans all the objects and executables of the built models and KitFox. Re-compiling KitFox requires to repeat all the steps from building the models.
$ make distclean

3.4. Linking KitFox to Architecture Simulator

When compiling the architecture simulator to use KitFox, the archive files of the models and KitFox have to be linked properly. If some models are not build in the previous steps, they should not be linked.
LDFLAGS += -lKitFox -ldramsim -ldsent -lintsim -lmcpat -ltsv -lfailure -l3dice -lhotspot
-lmicrofluidics -L$(KITFOX_DIRECTORY)

4. Test

4.1. Test Individual Models

KitFox provides the test examples included in the test_main directory.
The following command compiles and does a test-run of a model. Each test run loads the configuration file config/<model>.config.
$ make test-<model name>
$ ./test-<model name>

For example, the following command executes a test-run of HotSpot. This example loads the configuration file config/hotspot.config.
$ make test-hotspot
$ ./test-hotspot

To compile and run the test examples of the entire models built in the previous steps, the following command can be typed:
$ make test

5. Contacts

For any questions regarding KitFox, please contact William Song: