L PREPRINT - accepted by 30th IFIP/IEEE International Conference on Very Large
Scale Integration 2022 (VLSI-SoC 2022)3.5cm,1cm1.001.8

# NISTT: A Non-Intrusive SystemC-TLM 2.0
Tracing Tool

Nils Bosbach, Jan Moritz Joseph, and Rainer Leupers  Institute for
Communication Technologies and Embedded Systems
RWTH Aachen University
Aachen, Germany
{bosbach, joseph<EMAIL_ADDRESS>Lukas Jünger  MachineWare GmbH
Aachen, Germany
<EMAIL_ADDRESS>
###### Abstract

The increasing complexity of systems-on-a-chip requires the continuous
development of electronic design automation tools. Nowadays, the simulation of
systems-on-a-chip using virtual platforms is common. Virtual platforms enable
hardware/software co-design to shorten the time to market, offer insights into
the models, and allow debugging of the simulated hardware. Profiling tools are
required to improve the usability of virtual platforms. During simulation,
these tools capture data that are evaluated afterward. Those data can reveal
information about the simulation itself and the software executed on the
platform.

This work presents the tracing tool NISTT that can profile SystemC-
TLM-2.0-based virtual platforms. NISTT is implemented in a completely non-
intrusive way. That means no changes in the simulation are needed, the source
code of the simulation is not required, and the traced simulation does not
need to contain debug symbols. The standardized SystemC application
programming interface guarantees the compatibility of NISTT with other
simulations. The strengths of NISTT are demonstrated in a case study. Here,
NISTT is connected to a virtual platform and traces the boot process of Linux.
After the simulation, the database created by NISTT is evaluated, and the
results are visualized. Furthermore, the overhead of NISTT is quantified. It
is shown that NISTT has only a minor influence on the overall simulation
performance.

###### Index Terms:

SystemC, TLM, ESL, LD_PRELOAD

††publicationid: pubid: 978-1-6654-9005-4/22/$31.00 ©2022 IEEE

AAPCS64

    Procedure Call Standard for the  64-bit Architecture
AArch64

     ARM 64-bit Architecture
AI

    Artificial Intelligence
AIBA

    An Automated Intra-cycle Behavioral Analysis for SystemC-based design exploration
AMD

    Advanced Micro Devices
API

    Application Programming Interface
ARM

    Advanced RISC Machines
AST

    Abstract Syntax Tree
AVP64

    An ARMv8 Virtual Platform
BL

    Branch-With-Link
BP

    breakpoint
CPU

    Central Processing Unit
CRC

    Cyclic Redundancy Check
CSV

    Character-Separated Values
DB

    database
DBMS

     db Management System
DDR

    Double Data Rate
DES

    Discrete Event Simulation
DLA

    Deep Learning Accelerator
DMI

    Direct Memory Interface
DS

    Developer Studio
DWARF

    Debugging With Arbitrary Record Formats
EDA

    Electronic Design Automation
ELF

    Executable and Linkable Format
ESA

    European Space Agency
ESL

    Electronic System Level
fd

    file descriptor
FIG

    Fault Injection in glibc
FP

    Frame Pointer
FPGA

    Field Programmable Gate Array
FVP

    Fixed Virtual Platform
GCC

    GNU Compiler Collection
GDB

    GNU Debugger
GIC

    Generic Interrupt Controller
GOT

    Global Offset Table
GUI

    Graphical User Interface
HW

    Hardware
IBM

    International Business Machines
ID

    identifier
IEEE

    Institute of Electrical and Electronics Engineers
I/O

    Input/Output
IR

    Intermediate Representation
IRQ

    Interrupt Request
ISS

    Instruction-Set Simulator
LR

    Link Register
MISO

    Master Input Slave Output
MNIST

    Modified National Institute of Standards and Technology
MOSI

    Master Output Slave Input
NVDLA

    NVIDIA Deep Learning Accelerator
OS

    Operating System
PC

    Program Counter
PID

    process ID
PCCTS

    Purdue Compiler Construction Tool Set
PCI

    Peripheral Component Interconnect
PLT

    Procedure Linkage Table
PMU

    Performance Monitoring Unit
QEMU

    Quick Emulator
RAM

    Random-Access Memory
RISC

    Reduced Instruction Set Computer
$\operatorname{RTF}$

    Real-Time Factor
RTL

    Register-Transfer Level
RTOS

    real-time operating system
SATA

    Serial AT Attachment
SD

    Secure Digital
SDHCI

     SD Host Controller Interface
SoC

    System-on-a-chip
SP

    Stack Pointer
SPI

    Serial Peripheral Interface
SQL

    Structured Query Language
SSD

    Solid State Drive
SW

    Software
TCP

    Transmission Control Protocol
TLM

    Transaction-level Modeling
UART

    Universal Asynchronous Receiver / Transmitter
UNIX

    Uniplexed Information and Computing Service
VCD

    Value Change Dump
VCML

    Virtual Components Modeling Library
VIPER

    Virtual Platform Explorer
VP

    Virtual Platform
WFI

    Wait For Interrupt

##  I Introduction

Nowadays, simulation is an important part of the design process of a System-
on-a-chip (SoC). Virtual Platforms can be developed in an early stage of the
design process to serve as the enabler of Hardware (HW)/ Software (SW) co-
design. A VP is a simulation of a complete SoC that can execute target SW
without modification. To support the development, standardized frameworks like
SystemC-TLM 2.0 are used [1]. SystemC defines standardized interfaces for
models and their connection at the Electronic System Level (ESL). The
Transaction-level Modeling (TLM) extension abstracts communications between
models like memory accesses or interrupts to speed up the simulation.

Compared to real HW, VPs have the benefit of allowing easy debugging and
analysis. Due to Moore’s law and the related increasing complexity of SoCs,
simulations have also become more nested and complex. This problem leads to
performance issues in the simulation and the target SW. Additional tools are
required to reveal which parts of the simulation or the target SW need to be
optimized to overcome those issues. Those tools are called SystemC frontends.
A distinction is made between static, dynamic, and hybrid approaches. Static
approaches analyze the source code of the simulation and extract information
without executing the simulation. Dynamic techniques take the dynamic behavior
of the simulation into account. Modules that are created during runtime and
the workload that is executed on the VP are considered. For that, the
simulation is executed and analyzed. Hybrid approaches combine the two
techniques by analyzing both the static and the dynamic behavior. Often,
static analysis is used to search and annotate functions of interest. Based on
those annotations, the dynamic behavior is analyzed. The static evaluation
requires a tool that reads the source code of the simulation. This tool can
either be a parser or a compiler.

VP NISTT SystemC Evaluation Simulation Figure 1: NISTT approach.

In this paper, we present NISTT as a novel approach to tracing the behavior of
SystemC-TLM-2.0-based simulations. The design goals of NISTT are:

  * •

Revealing insights of the simulation and the target SW

  * •

Tracing of pre-compiled VPs without debugging symbols

  * •

No access to the source code of the simulation

  * •

Capturing the dynamic behavior without a static analysis

As shown in Fig. 1, NISTT is placed between the VP and the SystemC library. It
can intercept function calls to the SystemC library to analyze data. NISTT
does not place any requirements on the simulation or the used toolchain. The
official SystemC library and the preferred toolchain can be used without
changes. The standardization of the SystemC Application Programming Interface
(API) guarantees compatibility. Furthermore, NISTT is invisible to the
simulation. The simulation behavior is untouched.

##  II Related Work

TABLE I: Overview of existing SystemC frontends. SystemC Frontend | Analysis | Non-Intrusive | Works Without Access To |  Used Tools
---|---|---|---|---
Static | Dynamic | Source Code | Debug Symbols
SystemCXML [2] | ✓ |  | ✓ | ✗ | ✓ |  Doxygen
ParSysC [3] | ✓ |  | ✓ | ✗ | ✓ |  Parser
Genz et al. [4] | ✓ | ✓ | ✓ | ✗ | ✓ |  PCCTS-based parser
Pinapa [5] | ✓ | ✓ | ✗ | ✗ | ✓ |  Modified GCC, modified SystemC library
PinaVM [6] | ✓ | ✓ | ✗ | ✗ | ✓ |  LLVM, modified SystemC library
SHaBE [7] | ✓ | ✓ | ✓ | ✗ | ✗ |  GCC plugin, GDB
AIBA [8] | ✓ | ✓ | ✓ | ✗ | ✗ |  GDB
Quiny [9] |  | ✓ | ✗ | ✗ | ✓ |  Modified SystemC library
Scoot [10] | ✓ |  | ✗ | ✗ | ✓ |  Custom C++ frontend, simplified SystemC library
ReSp [11] |  | ✓ | ✓ | ✗ | ✓ |  Python wrapper
Stoppe et al. [12] | ✓ | ✓ | ✓ | ✗ | ✗ |  Debug symbols, SystemC API
NISTT |  | ✓ | ✓ | ✓ | ✓ |  LD_PRELOAD

Over the past years, many SystemC frontends have been developed. An overview
of different frontends has been created by Marquet et al. in [13]. Table I
shows an extended compilation of existing approaches. As mentioned before, the
approaches can be classified as static, dynamic, or hybrid.

The static approaches are often based on a parser that analyzes the C++ source
code of the simulation and derives information from the parsed output.
Different approaches for the implementation of the parser exist. SystemCXML
[2] uses Doxygen’s C++ front end to parse the module code. ParSysC [3] uses a
Purdue Compiler Construction Tool Set (PCCTS)-based parser to convert the
SystemC representation to a Register-Transfer Level (RTL) Intermediate
Representation (IR) to analyze the simulated system. Genz et al. also
developed a PCCTS-based parser for the static analysis and a code generator
that injects additional code into the simulation to evaluate runtime
information [4].

A problem that often occurs when SystemC parsers are used is the limitation to
a subset of the SystemC language. Therefore, compilers can be used instead of
parsers to extract static information. Pinapa [5] uses a modified GNU Compiler
Collection (GCC) to get the abstract syntax tree of the simulation from which
static information is extracted. Dynamic information is extracted by executing
the elaboration phase of the simulation, in which SystemC builds up the module
hierarchy. Pinapa has been further developed to PinaVM [6]. PinaVM uses the
LLVM IR to insert additional code into the simulation that is used to capture
runtime information.

SHaBE [7] and AIBA [8] use GNU Debugger (GDB) to debug the simulation during
execution. SHaBE uses a GDB plugin to extract data during the elaboration
phase to build up the module hierarchy. AIBA creates a GDB command file from a
static analysis which controls GDB during the execution to set breakpoints and
store data. This approach has been further developed to support the tracing of
TLM transactions [14]. Quiny [9] is a dynamic approach that uses a modified
SystemC library that implements C++ operator overloading to retrieve
information during runtime. Scoot [10] is a model extractor based on a custom
C++ frontend that analyzes the source code using simplified SystemC header
files to extract the module hierarchy, sensitivity list of the processes, and
the port bindings. ReSp [11] adds Python wrappers to SystemC models which
allow interaction during the simulation. The approach proposed by Stoppe et
al. [12] uses the debug information of the compiled simulation executable and
the SystemC API to capture simulation-related data.

Most presented static approaches try to extract the module hierarchy and the
connections between the modules. This information does not include the runtime
behavior of the simulation. Furthermore, all approaches need access to the
source code of the simulation to either directly analyze it or compile the
simulation using customized tools. That can be a drastic limitation,
especially for industrial VPs where the source code is not distributed to the
customer. Another aspect that stood out is the need for an extensive static
analysis most hybrid approaches use to configure their dynamic analysis. It
would be beneficial to perform the dynamic analysis without a preceding static
one to keep the complexity of the tool as low as possible. For those reasons,
the idea for the development of NISTT is to create a tracing tool that works
without a static analysis, does not require access to the source code of the
simulation, and is as simple as possible.

##  III Proposed NISTT Approach

The design idea behind NISTT is to create a tool that is capable of tracing an
already compiled SystemC-TLM-2.0-based simulation without accessing its source
code or debug symbols. These requirements increase the usability of the
tracing tool compared to existing approaches. To trace an already compiled
simulation, NISTT intercepts the calls of the simulation to the shared SystemC
library to extract data. The interception of function calls without access to
the source code can be done due to the standardized SystemC API. The
LD_PRELOAD feature of the Linux dynamic linker/loader, ld, is used to perform
this interception. ld is responsible for loading shared libraries that are
needed by a program. During runtime, ld dynamically links function calls to
those libraries. The shared libraries that are needed by an executable are
listed in the dynamic section of the compiled Executable and Linkable Format
(ELF) file. The Linux environment variable LD_PRELOAD can be used to define
paths of additional shared libraries that are loaded by ld, regardless of
whether they are required by the executable or not. When the executable calls
a function that is defined in a shared library, ld needs to resolve that call.
The matching of the function to be called and the available functions is based
on the function name. In the case of a C program, that name corresponds to the
name given by the programmer. For C++ programs, a mangled name is used that is
created by the compiler based on the name, return type, and parameter types of
the function.

Preloading a library that contains a function with the same name as a function
of a required shared library overrides the implementation of that function.
When the executable calls the function, ld resolves the call. ld searches for
an implementation of that function in the loaded shared objects. The first
function that is found is the one implemented in the preloaded library because
it is loaded before the required libraries. Thus, preloading can be used to
intercept calls to a shared library by implementing a function with the same
name in a preloaded library.

###  III-A Working Principle of NISTT

NISTT uses LD_PRELOAD to intercept calls to the SystemC library and extract
tracing information. That enables interaction with the simulation without
changing or accessing the source code of the simulation or dependent
libraries. The only requirement is that the simulation must be dynamically
linked against a SystemC-TLM-2.0-compatible library.

The working principle of NISTT is shown in Fig. 2. NISTT is a library that
needs to be preloaded to a SystemC-TLM-2.0-based simulation using LD_PRELOAD.
The library implements SystemC functions whose calls and passed data should be
traced. When the simulation calls such a function, ld links the call to the
NISTT implementation 1. NISTT can then access and evaluate the passed
parameters and store a data point in a database 2. The original SystemC
function is called afterward to keep the simulation behavior unchanged 3. For
that, the API of the Linux dynamic linker/loader is used. After the original
SystemC function returns 4, a second data point can be stored in the database
5. Then, the NISTT function returns 6. When the simulation calls a SystemC
function that is not implemented in NISTT, dl directly forwards the call to
the original library, as shown by the solid arrows on the left.

Models Accellera SystemC VP Preloaded NISTT Post Processing 134625Simulation
Figure 2: NISTT working principle.

###  III-B Traced SystemC Functions

NISTT can trace the following simulation properties:

  * •

SystemC process/coroutine scheduling

  * •

Quantum duration of processes

  * •

Processes waiting on event notifications

  * •

Notification of events

  * •

Course of simulation time and real-time

NISTT overrides multiple variants of the SystemC function wait to intercept
its calls. wait can be used inside SystemC threads to suspend the execution of
the thread in a non-preemptive way and resume it at a later point in time.
Parameters can be passed to the wait function to specify when the SystemC
scheduler should resume the execution of the thread. One variant of the wait
function accepts an amount of simulation time that needs to pass until the
thread is resumed. Another implementation gets a SystemC event or a collection
of SystemC events as a parameter. In that case, the thread is resumed once the
events have been notified. When an overridden wait function of NISTT is
called, the name of the calling SystemC process and simulation time/real-time
timestamps are stored in a database along with information on the duration of
the suspension. Depending on the parameters of the wait function, that
information is either the amount of simulation time that should be waited or
the name of the event that needs to be notified.

The data stored on wait calls can be used for various analyses. For instance,
they provide information on the scheduling of SystemC threads. SystemC threads
are coroutines that use the wait function to suspend their execution by
calling the scheduler. During an intercepted wait call, the first data point
is stored in the database when the execution of a thread is suspended 2.
Before the thread is resumed, a second data point is stored 5. To trace the
first entry into a thread, NISTT also intercepts calls to the function
sc_thread_cor_fn. This function is used to invoke a coroutine.

Another property that can be derived from wait calls is the quantum duration.
In loosely-timed SystemC-TLM 2.0 simulations, the concept of temporal
decoupling is used. Thereby, the simulation performance is increased by
reducing the temporal accuracy. SystemC threads are allowed to run ahead of
the global simulation time to decrease the number of synchronizations. They
keep the elapsed time since their last synchronization with the global
simulation time as their local time. When the local time of a thread exceeds a
limit or an operation that requires high accuracy should be executed, the
thread needs to synchronize with the global simulation time. This
synchronization is done by calling the wait function with the difference in
time as a parameter. This difference in time is called quantum. The used
quantum durations of the process provide information on the simulation
performance. In general, large quantum durations are targeted because they
increase the decoupling and thereby accelerate the simulation.

Apart from the wait function that gets a time as a parameter, SystemC also
offers a function to suspend the execution of a thread until a specified event
is notified. This function can, e.g., be used in the implementation of a CPU
model to implement a Wait For Interrupt (WFI) instruction. To emulate the
execution of WFI on a VP, wait can be called with the interrupt event as
parameter. Besides tracing threads that are waiting on notifications of
events, NISTT can also trace the notification itself. For that, the SystemC
function notify of the class sc_event is implemented in NISTT to intercept
calls. Depending on the parameters, the event is directly notified, or the
notification is delayed by the specified amount of simulation time.

Every data point that is stored in the database contains timestamps of the
current simulation time and the elapsed real-time since the beginning of the
simulation. Those two timestamps can be used to put the simulation time
$t_{sim}$ in relation to the time needed for the simulation, the real-time
$t_{real}$. The Real-Time Factor ($\operatorname{RTF}$) can be calculated to
measure the simulation performance.

$\operatorname{RTF}=\frac{\Delta t_{sim}}{\Delta t_{real}}$

The data stored in the database can be visualized and evaluated in a post-
processing step. Visualizations using Python and Matplotlib [15] are presented
in the next chapter.

In the future, additional SystemC functions can be implemented in NISTT to
extend the functionality. However, there are some limitations. Inlined SystemC
functions and methods defined in template classes cannot be overridden using
preloading. That is because they are directly compiled into the executable
that uses those functions and therefore not stored in the shared library.

##  IV Experimental Evaluation

NISTT is used to profile the boot process of a VP in a case study to
demonstrate the functionality of the tool. The tracing overhead is measured
and compared to an intrusive implementation. As the profiled target, the
Virtual Components Modeling Library (VCML)-based [16] VP AVP64 [17] is used.
Since NISTT is implemented in a non-intrusive way, no changes in SystemC,
VCML, or AVP64 are needed.

Fig. 3 depicts the architecture of the VP. It consists of an ARMv8 CPU and
peripherals that are connected via a bus. Interrupts are implemented by a TLM-
based interrupt protocol. An Operating System (OS) kernel like Linux can be
booted from a virtual Secure Digital (SD) card using the  Host Controller
Interface (SDHCI). PL011 ARM PrimeCell UART models serve as user interface.
They can be configured to print their output to the host’s terminal and read-
in user input. The VP is a loosely-timed simulation, i.e., the SystemC threads
are temporal decoupled, keep their local time, and regularly synchronize with
the simulation time. Memory accesses and interrupts are implemented by TLM
transactions.

All benchmarks have been executed on a computer equipped with a AMD Ryzen 9
3900X 12-Core CPU, $64\text{\,}\mathrm{GB}$ RAM, and a Samsung 860 EVO SATA
III SSD, running CentOS 7.9 with Linux 3.10.0. The maximum allowed quantum
duration for the simulation was $100\text{\,}\mathrm{\SIUnitSymbolMicro s}$.

BUS CPU GIC UART MEM SDHCI ETHOC RNG TLM Initiator SocketTLM Target SocketTLM
Interrupt Initiator SocketTLM Interrupt Target Socket Figure 3: AVP64
architecture.

###  IV-A Case Study

AVP64 was started with NISTT being preloaded. Fig. 4 depicts the captured
results of the first $2\text{\,}$ seconds of the Linux boot process. The
$\operatorname{RTF}$ during the simulation is shown in Fig. 4a. It can be
observed that the $\operatorname{RTF}$ fluctuates during the simulation. This
fluctuation depends on the workload that is executed on the VP. Different
parts of the workload cause different CPU utilization. When the utilization is
low, idle cycles of the CPU are not simulated, which increases the
performance. Besides that aspect, interactions with peripherals can also
reduce the $\operatorname{RTF}$ due to early quantum terminations.

Fig. 4b shows the used quantum durations of the CPU thread. During the periods
where the $\operatorname{RTF}$ is low, the quanta are comparatively small. If
no data points are printed, that point in time has not been simulated for the
CPU model. The reason for that is that the state of the CPU stayed unchanged
during that time. That is, e.g., the case when the CPU is in idle mode. The
Linux idle mode is implemented by executing the WFI instruction. AVP64
emulates this instruction by using the SystemC wait function with the
interrupt event as a parameter. Thereby, the execution of the processor thread
is suspended until the next interrupt raises.

Fig. 4c visualizes the notified SystemC events. The IN_FREE event is used by
the VCML register model to serialize parallel accesses to TLM target sockets
of a peripheral. It is notified after each handled transaction of the
corresponding peripheral. That means, every time the IN_FREE event is
notified, a register of the peripheral has been written. Thus, the figure
reveals when interactions with peripherals take place.

Besides the IN_FREE event, the events IRQ[0]_ev and arm_timer_ns of the CPU
model are of importance. The first event, IRQ[0]_ev, is notified every time an
interrupt is signaled to the CPU by the Generic Interrupt Controller (GIC).
That is the reason why the notification pattern of the IRQ[0]_ev of the CPU
and the IN_FREE event of the GIC look similar. Every time an interrupt is
signaled to the CPU, the CPU interacts with the CPU interface of the GIC to
handle and acknowledge the interrupt. The second event of the CPU,
arm_timer_ns, is used to implement a timer. When the timer is set to expire
after a certain time, the event is programmed to be notified at this time.
This delayed notification is visualized in Fig. 4c by an arrow starting at the
time of programming and pointing to the time of expiration. There are three
periods during the boot process where the timer is programmed to expire after
a comparatively long period of time
($0.4\text{\,}\mathrm{s}$-$1.1\text{\,}\mathrm{s}$;
$1.1\text{\,}\mathrm{s}$-$1.3\text{\,}\mathrm{s}$;
$1.3\text{\,}\mathrm{s}$-$1.8\text{\,}\mathrm{s}$). During these periods, no
quantum data were recorded. That strengthens the assumption that the OS was in
idle mode during those periods and used the timer to wake up.

(a) Real-time factor.

(b) Quantum durations of the processor thread.

(c) Excerpt of notified SystemC events.

Figure 4: Tracing results of the first $2\text{\,}\mathrm{s}$ of Linux boot.

Table II shows the needed computation time to execute the SC_THREADs of the
VP. The simulation of $2\text{\,}\mathrm{s}$ of the Linux boot took
$29.15\text{\,}\mathrm{s}$. $96\text{\,}\mathrm{\char 37\relax}$ of the
simulation, the processor thread of the CPU model was active. Since the boot
process is used as the benchmark, the CPU was the most compute-intensive model
of the platform.

TABLE II: SystemC thread execution time during $2\text{\,}\mathrm{s}$ of Linux boot. Module | SC_THREAD | Compute Time ($\mathrm{s}$) | Amount ($\mathrm{\char 37\relax}$)
---|---|---|---
System | timeout | $0.000\,001$ | $0.000\,003$
ETHOC | tx_process | $0.002\,494$ | $0.008\,556$
2-3 | rx_process | $0.002\,670$ | $0.009\,160$
SDHCI | dma_tread | $0.239\,657$ | $0.822\,207$
CPU | processor_thread | $27.978\,902$ | $95.989\,095$
Total |  | $28.223\,724$ | $96.829\,022$

###  IV-B Performance

The idea of NISTT is to trace the execution of a VP and to place as few
requirements as possible on the simulation. Therefore, LD_PRELOAD is used to
limit the requirements to the usage of a shared SystemC library. This section
examines whether the performance of NISTT is reduced due to its non-intrusive
implementation. If changing simulation-dependent libraries had not conflicted
with the requirements, instrumentation of functions of interest inside the
SystemC library would have been an alternative implementation with the same
tracing results as NISTT. This alternative, intrusive implementation is
compared to NISTT to evaluate the differences in performance. Furthermore, the
general overhead of NISTT is classified.

The simulation of the VP is executed in four different configurations to
evaluate the tracing overhead of NISTT. As shown in Table III, the
configurations differ in the tracing implementation and the way the simulation
is linked against SystemC. NISTT requires a dynamic linkage against SystemC to
work. The intrusive reference implementation is used to profile the overhead
of intercepting function calls using preloading. As a reference, the execution
time of the unmodified VP without tracing is measured.

TABLE III: Tracing implementations. Name | Tracing | SystemC Linkage
---|---|---
Reference | - | dynamic
I,static | intrusive | static
I,shared | intrusive | dynamic
NI,shared (NISTT) | non-intrusive | dynamic

The first $2\text{\,}\mathrm{s}$ of the Linux boot process are again used as
the benchmark to quantify the overhead of NISTT and the two intrusive
implementations compared to the reference VP without tracing. Fig. 5 shows the
results for the different configurations and different activated traces.

When the tracing is implemented but deactivated (cf. None), i.e., additional
functions are present in either SystemC or the preloaded NISTT library, but
data are not stored in a database, the execution times are similar to the one
of the reference implementation without tracing. In general, no clear relation
between used linking and needed execution time could be detected. Even NISTT
does not harm the simulation performance compared to the corresponding
intrusive implementation. What is noticeable, however, is that the kind of
tracing that is enabled has an influence on the execution time. That is
because the traces are executed with different frequencies and therefore cause
various overheads. The Wait for Event trace, e.g., is only triggered
$68\text{\,}$ times during the simulation and therefore caused only a little
overhead. The Quantum trace captured $94\,174\text{\,}$ data points which
results in a visibly higher execution time. The highest overhead is created,
and most data points are stored, by the Event trace ($195\,064\text{\,}$ data
points) and the SystemC Process trace ($208\,174\text{\,}\mathrm{d}$ata
points). Those results show that the produced overhead is mainly caused by the
kind of the trace rather than its implementation (intrusive/non-intrusive) or
used linkage. However, a non-intrusive implementation like NISTT has the
advantage that the simulation does not need to be adapted to the tool. The
standardized SystemC API assures compatibility. Furthermore, no access to the
source code of the simulation is needed for the non-intrusive implementation.
The simulation itself stays unchanged and does not need to be recompiled to be
traced.

Figure 5: Overhead of tracing during Linux boot simulation for the intrusive
(I) and non-intrusive (NI) implementations. Results of $20$ runs.

##  V Conclusion

This paper presents a novel approach for tracing a SystemC-TLM-2.0-based
simulation in a non-intrusive way. Due to the standardization of the SystemC
API, NISTT can trace every simulation that is based on SystemC without making
special requests to the implementation. Source code or debug symbols of the
simulation are not needed, which drastically increases the usability compared
to existing approaches. NISTT stores the captured tracing data in a database
to allow evaluation and analysis in a post-processing step. We showed that the
non-intrusive implementation of NISTT does not reduce the performance compared
to an intrusive one. The non-intrusive implementation has the advantage of not
requiring compile-time modifications. Thereby, also VPs can be analyzed where
the source code can not be accessed.

However, there is also a limitation of NISTT due to its implementation using
preloading. NISTT is only capable of redirecting calls to SystemC functions
that are located in the library object file. Thereby, calls to inlined
functions or functions of template classes cannot be intercepted. Despite this
limitation, NISTT is a powerful tool that offers deep insights into SystemC-
TLM-2.0-based simulations like VPs without the need of having access to their
source code. It can capture relevant ESL-simulation data and can easily be
extended to trace additional functions of interest.

## References

  * [1] IEEE Standards Association and others, “IEEE standard for standard SystemC language reference manual,” pp. 1–638, conference Name: IEEE Std 1666-2011 (Revision of IEEE Std 1666-2005).
  * [2] D. Berner, J.-P. Talpin, H. D. Patel, D. Mathaikutty, and S. K. Shukla, “SystemCXML: An exstensible SystemC front end using XML.” in _FDL_ , pp. 405–409.
  * [3] G. Fey, D. Große, T. Cassens, C. Genz, T. Warode, and R. Drechsler, “ParSyC: an efficient SystemC parser,” in _In SASIMI_. Citeseer.
  * [4] C. Genz and R. Drechsler, “Overcoming limitations of the SystemC data introspection,” in _2009 Design, Automation & Test in Europe Conference & Exhibition_. IEEE, pp. 590–593.
  * [5] M. Moy, F. Maraninchi, and L. Maillet-Contoz, “Pinapa: An extraction tool for systemc descriptions of systems-on-a-chip,” in _Proceedings of the 5th ACM international conference on Embedded software_ , pp. 317–324.
  * [6] K. Marquet and M. Moy, “PinaVM: a SystemC front-end based on an executable intermediate representation,” in _Proceedings of the tenth ACM international conference on Embedded software_ , pp. 79–88.
  * [7] H. Broeders and R. Van Leuken, “Extracting behavior and dynamically generated hierarchy from SystemC models,” in _2011 48th ACM/EDAC/IEEE DAC_. IEEE, pp. 357–362.
  * [8] M. Goli, J. Stoppe, and R. Drechsler, “AIBA: an automated intra-cycle behavioral analysis for SystemC-based design exploration,” in _2016 IEEE 34th International Conference on Computer Design (ICCD)_. IEEE, pp. 360–363.
  * [9] T. Schubert and W. Nebel, “The quiny SystemCTM front end: Self-synthesising designs,” in _Advances in Design and Specification Languages for Embedded Systems_. Springer, pp. 93–109.
  * [10] N. Blanc, D. Kroening, and N. Sharygina, “Scoot: A tool for the analysis of SystemC models,” in _International Conference on Tools and Algorithms for the Construction and Analysis of Systems_. Springer, pp. 467–470.
  * [11] G. Beltrame, L. Fossati, and D. Sciuto, “Resp: A nonintrusive transaction-level reflective mpsoc simulation platform for design space exploration,” vol. 28, no. 12, pp. 1857–1869, publisher: IEEE.
  * [12] J. Stoppe, R. Wille, and R. Drechsler, “Data extraction from SystemC designs using debug symbols and the SystemC API,” in _2013 IEEE Computer Society Annual Symposium on VLSI (ISVLSI)_. IEEE, pp. 26–31.
  * [13] K. Marquet, M. Moy, and B. Karkare, “A theoretical and experimental review of SystemC front-ends,” in _2010 Forum on Specification & Design Languages (FDL 2010)_. IET, pp. 1–6.
  * [14] M. Goli, J. Stoppe, and R. Drechsler, “Automated nonintrusive analysis of electronic system level designs,” vol. 39, no. 2, pp. 492–505.
  * [15] J. D. Hunter, “Matplotlib: A 2d graphics environment,” vol. 9, no. 3, pp. 90–95, publisher: IEEE COMPUTER SOC.
  * [16] J. H. Weinstock, “Virtual components modeling library (vcml),” original-date: 2018-01-22T10:24:21Z. [Online]. Available: https://github.com/janweinstock/vcml
  * [17] L. Jünger, J. H. Weinstock, R. Leupers, and G. Ascheid, “Fast SystemC processor models with unicorn,” in _Proceedings of the Rapid Simulation and Performance Evaluation: Methods and Tools_ , ser. RAPIDO ’19. Association for Computing Machinery, pp. 1–6. [Online]. Available: https://doi.org/10.1145/3300189.3300191

  *[]:
  *[ARM]: Advanced  Machines
  *[RISC]: Reduced Instruction Set Computer
  *[SD]: Secure Digital
  *[SoC]: System-on-a-chip
  *[HW]: Hardware
  *[SW]: Software
  *[VP]: Virtual Platform
  *[TLM]: Transaction-level Modeling
  *[ESL]: Electronic System Level
  *[VPs]: Virtual Platform
  *[SoCs]: System-on-a-chip
  *[API]: Application Programming Interface
  *[PCCTS]: Purdue Compiler Construction Tool Set
  *[GCC]: GNU Compiler Collection
  *[GDB]: GNU Debugger
  *[RTL]: Register-Transfer Level
  *[IR]: Intermediate Representation
  *[ELF]: Executable and Linkable Format
  *[WFI]: Wait For Interrupt
  *[$\operatorname{RTF}$]: Real-Time Factor
  *[VCML]: Virtual Components Modeling Library
  *[AVP64]: An v8
  *[OS]: Operating System
  *[SDHCI]:  Host Controller Interface
  *[UART]: Universal Asynchronous Receiver / Transmitter
  *[AMD]: Advanced Micro Devices
  *[RAM]: Random-Access Memory
  *[SATA]: Serial AT Attachment
  *[SSD]: Solid State Drive
  *[GIC]: Generic Interrupt Controller


# Radiatively induced finite and (un)determined Chern-Simons-like terms

Eduardo Passos
Departamento de Física, Universidade Federal da Paraíba, Caixa Postal 5008,
58051-970 João Pessoa, Paraíba, Brazil
E-mail<EMAIL_ADDRESS>
###### Abstract:

The problem of Chern-Simons-like term induction via quantum corrections in
four-dimensions is investigated in two different cases. In the first case, we
consider two distinct approaches to deal with the exact fermion propagator of
the extended QED theory up to the first order in the $b$-coefficient. We find
different results for distinct approaches in the same regularization scheme.
In the second case, we show that when we use a modified derivative expansion
method and another regularization scheme, we obtain a result that exactly
coincides with one of the results obtained in the former case. This seems to
imply an ambiguity absence as one treats the fermion propagator and the self-
energy tensor properly.

Chern-Simons Theories, Space-Time Symmetries, Quantum Corrections

##  1 Introduction

The induction of the Chern-Simons-like Lorentz and CPT violating term, given
by ${\cal
L}_{CS}=\frac{1}{2}k_{\mu}\epsilon^{\mu\nu\lambda\theta}F_{\nu\lambda}A_{\theta}$,
being $k_{\mu}$ a constant vector characterizing the preferred direction of
the space-time, is one of the most important results in the study of Lorentz
symmetry violation [2, 3]. This term which is known to have some important
implications, such as birefringence of light in the vacuum [4], naturally
emerges as a quantum correction in the theory suggested in [3] as a possible
extension of QED:

$\displaystyle{\cal
L}_{QED}=\bar{\psi}(i\partial\\!\\!\\!/-m)\psi-\bar{\psi}b\\!\\!\\!/\gamma_{5}\psi-e\bar{\psi}A\\!\\!\\!/\psi,$
(1)

where $b_{\mu}$ is a parameter introducing CPT symmetry breaking. Carrying out
the integration over fermions, the relation between the coefficients $k_{\mu}$
and $b_{\mu}$ could be obtained in terms of some loop integrals with some of
them being divergent. Therefore one has to implement some regularization
scheme to calculate these integrals. Thus, the constant relating the
coefficient $k_{\mu}$ and $b_{\mu}$ turns out to be dependent on the
regularization scheme used [5, 6]. Such dependence on the regularization
scheme has been intensively discussed in [7, 8, 9]. However, there is an
alternative study with absence of ambiguities put forward recently in [10].

Based on the theory (1), the purpose of our study is to investigate different
possibilities of finding ambiguities inherent to generation of Chern-Simons-
like term via quantum corrections in four dimensions. We do this by using
derivative expansion method of the fermion determinant [11] and the imaginary
time formalism.

The work structure is organized as follows: In section 2 we will investigate
the induction of the Chern-Simons-like term via quantum corrections by using
distinct approaches to deal with the exact fermion propagator. We find
distinct relations between the coefficients $k_{\mu}$ and $b_{\mu}$ for
different approaches, but with a same regularization scheme. Therefore, we
conclude that different approaches to deal with the exact fermion propagator
of the theory, leads to a new ambiguity for the problem of radiatively induced
Chern-Simons-like term. In section 3 we develop another method to investigate
the present issue. By modifying the derivative expansion method, we obtain a
different self-energy tensor. We then use a specific regularization scheme to
find a finite result identical to that obtained in section 2 by using another
regularization scheme. This effect seems to imply ambiguity absence in our
calculations. Finally, in section 4 we present our conclusions.

##  2 Inducing Chern-Simons-like term: Two different approaches

In this section, we focus on the induction of the Chern-Simons-like term
coefficient by expanding the self-energy (7) and using two distinct approaches
to deal with the exact fermion propagator (8) up to the leading order in $b$.
We find a new ambiguity because two different results appear.

The one-loop effective action $S_{eff}[b,A]$ of the gauge field $A_{\mu}$
related to theory (1), can be expressed in the form of the following
functional trace:

$\displaystyle S_{eff}[b,A]=-i\,{\rm
Tr}\,\ln(p\\!\\!\\!/-m-b\\!\\!\\!/\gamma_{5}-eA\\!\\!\\!/).$ (2)

This functional trace can be represented as
$S_{eff}[b,A]=S_{eff}[b]+S_{eff}^{\,\prime}[b,A]$, where the first term
$S_{eff}[b]=-i\,{\rm Tr}\ln(p\\!\\!\\!/-m-b\\!\\!\\!/\gamma_{5})$ does not
depend on the gauge field. The only nontrivial dynamics is concentrated in the
second term $S_{eff}^{\,\prime}[b,A]$, which is given by the following power
series:

$\displaystyle S_{eff}^{\,\prime}[b,A]=i\,{\rm
Tr}\sum_{n=1}^{\infty}\frac{1}{n}\Biggl{[}\frac{1}{p\\!\\!\\!/-m-b\\!\\!\\!/\gamma_{5}}\,eA\\!\\!\\!/\Biggr{]}^{n}.$
(3)

To obtain the Chern-Simons-like term we should expand this expression up to
the second order in the gauge field:

$\displaystyle S_{eff}^{\,\prime}[b,A]=S_{eff}^{(2)}[b,A]+\ldots$ (4)

The dots in (4) stand for higher order terms in the gauge field. Here

$\displaystyle S_{eff}^{(2)}[b,A]=\frac{ie^{2}}{2}{\rm
Tr}\Biggl{[}\frac{1}{p\\!\\!\\!/-m-b\\!\\!\\!/\gamma_{5}}\;A\\!\\!\\!/\;\frac{1}{p\\!\\!\\!/-m-b\\!\\!\\!/\gamma_{5}}\,\;A\\!\\!\\!/\Biggl{]}.$
(5)

Using the derivative expansion method [11] one can find that the one-loop
contribution to $S_{\rm eff}^{(2)}[b,A]$ reads

$S_{\rm eff}^{(2)}[b,A(x)]=\frac{1}{2}\int
d^{4}x\;\Pi^{\alpha\mu\nu}F_{\alpha\mu}A_{\nu},$ (6)

where the one-loop self-energy $\Pi^{\alpha\mu\nu}$ is given by

$\Pi^{\alpha\mu\nu}=-\frac{ie^{2}}{2}\int\,\frac{d^{4}p}{(2\pi)^{4}}\,\text{tr}\bigl{[}S_{b}(p)\,\gamma^{\mu}\,S_{b}(p)\,\gamma^{\alpha}\,S_{b}(p)\,\gamma^{\nu}\bigl{]},$
(7)

where

$\displaystyle S_{b}(p)=\frac{i}{p\\!\\!\\!/-m-b\\!\\!\\!/\gamma_{5}}$ (8)

is a $b^{\mu}$ dependent exact fermion propagator of the theory.

###  2.1 Approach I: Fermion propagator rationalized

Firstly, we use the approximation developed in [12], where the exact
propagator (8) is rationalized in the form

$S_{b}(p)=i\Big{[}\frac{p\\!\\!\\!/+m-\gamma_{5}b\\!\\!\\!/}{(p^{2}-m^{2})}-\frac{2\gamma_{5}(mb\\!\\!\\!/-(b\cdot
p))(p\\!\\!\\!/+m)}{(p^{2}-m^{2})^{2}}\Big{]}+\cdots.$ (9)

Substituting (9) into (7), we can calculate the trace of gamma matrices,
resulting in the following expression for the self-energy tensor [5]:

$\displaystyle\Pi^{\mu\alpha\nu}_{\bf r}$ $\displaystyle=$
$\displaystyle-2ie^{2}\int\,\frac{d^{4}p}{(2\pi)^{4}}\frac{1}{(p^{2}+m^{2})^{3}}\\{3\varepsilon^{\alpha\mu\nu\theta}\bigl{[}b_{\theta}(p^{2}-m^{2})-2p_{\theta}(b\cdot
p)\bigl{]}$ (10)
$\displaystyle-2b_{\theta}\bigl{[}\varepsilon^{\beta\mu\nu\theta}p_{\beta}p^{\alpha}+\varepsilon^{\alpha\beta\nu\theta}p_{\beta}p^{\mu}+\varepsilon^{\alpha\mu\beta\theta}p_{\beta}p^{\nu}\bigl{]}\\},$

where $\Pi^{\mu\alpha\nu}_{\bf r}$ means self-energy tensor is rationalized up
to the first order in $b$-coefficient. In Eq.(10), we turn the Minkowski space
to an Euclidean space by performing the Wick rotation $x_{0}\to-ix_{0}$,
$p_{0}\to ip_{0}$, $b_{0}\to ib_{0}$, $d^{4}x\to-id^{4}x$ and $d^{4}p\to
id^{4}p$. Note that by power counting, the momentum integral in (10) involves
a finite term and terms with logarithmic divergences. In order to regularize
such divergence, we use a scheme which we implement translation only on space
coordinates of the momentum $p_{\rho}$ [13]. Hence, we have

$\displaystyle p_{\rho}\to\vec{p}_{\rho}+p_{0}\delta_{0\rho}.$ (11)

We use the covariance under spatial rotations which allows us to carry out the
following replacement

$\displaystyle\vec{p}_{\rho}\vec{p}^{\sigma}\to\frac{\vec{p}^{2}}{D}(\delta^{\sigma}_{\rho}-\delta_{\rho
0}\delta^{\sigma}_{0}).$ (12)

Thus,

$\displaystyle 2p_{\rho}(b\cdot p)\to
2\left(b_{\rho}\frac{\vec{p}^{2}}{D}-b_{0}\delta_{\rho
0}(\frac{\vec{p}^{2}}{D}-p^{2}_{0})\right),$ $\displaystyle
2p_{\beta}p^{\alpha}\to
2\left(\delta_{\beta}^{\alpha}\,\frac{\vec{p}^{\,2}}{D}-\delta_{\beta
0}\delta_{0}^{\alpha}(\frac{\vec{p}^{2}}{D}-p^{2}_{0})\right).$ (13)

We have that only the terms above can contribute to the Chern-Simons
structure. Therefore, we can split the expression (5) into a sum of two parts,
“covariant” and “noncovariant”, i.e.,

$\displaystyle S^{\rm cov}_{\rm
eff}=\frac{(-i)}{2}\int\,d^{4}x\,I_{1}\varepsilon^{\alpha\mu\nu\beta}\,b_{\beta}F_{\alpha\mu}A_{\nu},$
(14)

with

$\displaystyle I_{1}$ $\displaystyle=$
$\displaystyle\frac{-3ie^{2}}{2\pi}\,\int\,\frac{d^{D}\vec{p}}{(2\pi)^{D}}\,\int_{-\infty}^{+\infty}\,dp_{0}\,\Big{[}\frac{(1-\frac{4}{D})\vec{p}^{2}+p_{0}^{2}-m^{2}}{(\vec{p}^{2}+p_{0}^{2}+m^{2})^{3}}\Big{]},$
(15)

and

$\displaystyle S^{\rm ncv}_{\rm eff}$ $\displaystyle=$
$\displaystyle\frac{i}{2}\int\,d^{4}xI_{2}\,\bigl{[}3\varepsilon^{\alpha\mu\nu
0}\,b_{0}F_{\alpha\mu}A_{\nu}+b_{\theta}(\varepsilon^{0\mu\nu\theta}F_{0\mu}A_{\nu}$
(16) $\displaystyle+\varepsilon^{\alpha 0\nu\theta}F_{\alpha
0}A_{\nu}+\varepsilon^{\alpha\mu 0\theta}F_{\alpha\mu}A_{0})\bigl{]},$

with

$\displaystyle
I_{2}=\frac{ie^{2}}{\pi}\,\int\,\frac{d^{D}\vec{p}}{(2\pi)^{D}}\int_{-\infty}^{+\infty}\,dp_{0}\,\Big{[}\frac{\frac{\vec{p}^{2}}{D}-p_{0}^{2}}{(\vec{p}^{2}+p_{0}^{2}+m^{2})^{3}}\Big{]}.$
(17)

The integrals $I_{1}$ and $I_{2}$ over $p_{0}$ are finite and can be
calculated by residues theorem. Hence, we have

$\displaystyle
I_{1}=\frac{3ie^{2}}{8D}\,\int\,\frac{d^{D}\vec{p}}{(2\pi)^{D}}\,\Big{[}\frac{2(3-D)\vec{p}^{\,2}+Dm^{2}}{(\vec{p}^{2}+m^{2})^{5/2}}\Big{]},$
(18)

and

$\displaystyle
I_{2}=-\frac{ie^{2}}{8D}\,\int\,\frac{d^{D}\vec{p}}{(2\pi)^{D}}\,\Big{[}\frac{(3-D)\vec{p}^{\,2}-Dm^{2}}{(\vec{p}^{2}+m^{2})^{5/2}}\Big{]}.$
(19)

Now, we can integrate over the spatial momentum in $D$-dimensions [16], and we
find,

$\displaystyle
I_{1}=\frac{3ie^{2}}{8(4\pi)^{D/2}}\frac{\Gamma{(1+\frac{\epsilon}{2})}}{\Gamma(\frac{5}{2})(m^{2})^{\epsilon/2}}$
(20)

where $\epsilon=3-D$. The integral $I_{2}$ presents a value identically equal
to zero. Therefore, the effective action Eq.(14) in the limit $D=3$ can be
written in the form

$\displaystyle S^{\rm cov}_{\rm
eff}=\frac{1}{2}\int\,d^{4}x\,\varepsilon^{\alpha\mu\nu\beta}\,k_{\beta}F_{\alpha\mu}A_{\nu},$
(21)

where

$\displaystyle k_{\beta}=\frac{e^{2}}{16\pi^{2}}\,b_{\beta},$ (22)

that coincides with the resulted of work [17] in the Schwinger constant field
approximation.

###  2.2 Approach II: Fermion propagator expansion

Now we use the approximation developed in [14] to expand the exact propagator
(8) up to the first order in $b$-coefficient

$\displaystyle
S_{b}(p)=\frac{i}{p\\!\\!\\!/-m}+\frac{i}{p\\!\\!\\!/-m}\,(-ib\\!\\!\\!/\gamma_{5})\,\frac{i}{p\\!\\!\\!/-m}+\cdot\cdot\cdot.$
(23)

In this case, we have our self-energy tensor in the form [6, 18]:

$\displaystyle\Pi^{\mu\alpha\nu}_{\bf e}$ $\displaystyle=$
$\displaystyle-2ie^{2}\epsilon^{\mu\alpha\nu\rho}\int\,\frac{d^{4}p}{(2\pi)^{4}}\,\frac{1}{(p^{2}+m^{2})^{3}}$
(24) $\displaystyle\times[b_{\rho}(p^{2}-3m^{2})-4p_{\rho}(b\cdot p)],$

where $\Pi^{\mu\alpha\nu}_{\bf e}$ means the expanded self-energy tensor. In
Eq.(24), we also change the Minkowski space to Euclidean space. Note that by
power counting, the integral in the momentum space Eq.(24) also present a
finite term and another that diverges logarithmically. Thus, we use the same
regularization scheme adopted in the rationalized fermion propagator approach.
In this way, we obtain the following effective action in the limit of $D=3$:

$\displaystyle\tilde{S}^{\rm cov}_{\rm
eff}=\frac{1}{2}\int\,d^{4}x\,\varepsilon^{\alpha\mu\nu\beta}\,\tilde{k}_{\beta}F_{\alpha\mu}A_{\nu},$
(25)

where

$\displaystyle\tilde{k}_{\beta}=\frac{e^{2}}{4\pi^{2}}\,b_{\beta}.$ (26)

Here, we also have the absence of “noncovariant” part. The result (26) is
equivalent to the obtained in [19] where one uses a physical cutoff for
fermions. According to the results (22) and (26), we found that the use of
different approaches to deal with the exact fermion propagator leads to
distinct relations between the coefficient $k_{\mu}$ and $b_{\mu}$ for the
Chern-Simons-like term. Our results establish the following relation:

$\displaystyle\tilde{k}_{\beta}=k_{\beta}+\frac{3e^{2}}{16\pi^{2}}\,b_{\beta},$
(27)

that means

$\displaystyle\Delta k_{\beta}=\frac{3e^{2}}{16\pi^{2}}\,b_{\beta}.$ (28)

The result (28) corresponds to variation between the results (22) and (26),
that is identical to the result of Ref. [18] originated from the self-energy
(24), in another regularization scheme. The same result has been found in the
literature [14, 15].

##  3 Other aspects on induced Chern-Simons-like term

In this section, we present an alternative method to compute induced Chern-
Simons-like term, that is independent of the approach used to deal with the
exact fermion propagator.

Let us rewrite the Eq.(3) in the form,

$\displaystyle S_{eff}^{\,\prime}[b,A]=i\,{\rm
Tr}\sum_{n=1}^{\infty}\frac{1}{n}\Biggl{[}\frac{1}{p\\!\\!\\!/-m-eA\\!\\!\\!/}\,b\\!\\!\\!/\gamma_{5}\Biggr{]}^{n}.$
(29)

To obtain the Chern-Simons-like term we should expand this expression up to
the leading order in $b$. Thus, for $n=1$, we have

$\displaystyle S_{eff}^{(1)}[b,A]$ $\displaystyle=$ $\displaystyle i{\rm
Tr}\Biggl{[}\frac{1}{p\\!\\!\\!/-m-eA\\!\\!\\!/}\;b\\!\\!\\!/\gamma_{5}\Biggl{]}.$
(30)

Using the relation

$\frac{1}{A-B}=\frac{1}{A}+\frac{1}{A}B\frac{1}{A}+\frac{1}{A}B\frac{1}{A}B\frac{1}{A}+\cdot\cdot\cdot$
(31)

for $A=p\\!\\!\\!/-m$ and $B=eA\\!\\!\\!/$, we find

$\displaystyle S_{eff}^{(1)}[b,A]=ie^{2}{\rm
Tr}\Biggl{[}\frac{1}{p\\!\\!\\!/-m}\,b\\!\\!\\!/\gamma_{5}\,\frac{1}{p\\!\\!\\!/-m}\,A\\!\\!\\!/\,\frac{1}{p\\!\\!\\!/-m}\,A\\!\\!\\!/\Biggl{]},$
(32)

where one was considered the cyclic property of the trace in the product of
the $\gamma$-matrices. By using derivative expansion method, we find the
following effective action:

$S_{\rm eff}^{(1)}[b,A(x)]=\frac{1}{2}\int
d^{4}x\;\Pi^{\alpha\mu\nu}F_{\alpha\mu}A_{\nu},$ (33)

where the one-loop self-energy $\Pi^{\alpha\mu\nu}$ is given by

$\displaystyle\Pi^{\mu\alpha\nu}$ $\displaystyle=$
$\displaystyle-2ie^{2}\int\,\frac{d^{4}p}{(2\pi)^{4}}\frac{1}{(p^{2}-m^{2})^{3}}\\{\varepsilon^{\alpha\mu\nu\theta}b_{\theta}(p^{2}-m^{2})$
(34)
$\displaystyle-2b_{\theta}\bigl{[}\varepsilon^{\alpha\nu\theta\beta}p_{\beta}p^{\mu}-\varepsilon^{\alpha\mu\theta\beta}p_{\beta}p^{\nu}\bigl{]}\\}.$

Note that in the self-energy tensor (34) there exists a convergent
contribution and the remaining term diverges logarithmically. However,
differently of the previous situations, in this case the calculation of the
divergent integrals is very delicate. Calculating this self-energy tensor by
using the same regularization scheme of the section 2, we find a null result,
and in turn, the absence of the Chern-Simons term. On the other hand, there
also exists the possibility of using in Eq.(34) the relation

$\int\frac{d^{4}p}{(2\pi)^{4}}p_{\mu}p_{\nu}\,f(p^{2})=\frac{g_{\mu\nu}}{4}\int\frac{d^{4}p}{(2\pi)^{4}}p^{2}\,f(p^{2}),$
(35)

that naturally removes the logarithmic divergence. As a result, we have only
the finite contribution

$\Pi^{\mu\alpha\nu}=\frac{e^{2}}{16\pi^{2}}\,\varepsilon^{\mu\alpha\nu\theta}\,b_{\theta}.$
(36)

In this case, we find

$S_{\rm eff}^{(1)}[b,A(x)]=\frac{1}{2}\int
d^{4}x\;k_{\beta}\varepsilon^{\mu\alpha\nu\beta}\partial_{\alpha}A_{\mu}A_{\nu},$
(37)

where

$k_{\beta}=\frac{e^{2}}{16\pi^{2}}b_{\beta}.$ (38)

Note that the result (38) is the same as the result found in (22) where the
exact fermion propagator was rationalized up to the first order in the
$b$-coefficient. Thus, we have here another surprising effect: The result
$k_{\beta}=\frac{e^{2}}{16\pi^{2}}b_{\beta}$ given in (22) as result of
dimensional regularization and also given in (38) as result of the Lorentz
preserving regularization (35), appears to be $independent$ of the
regularization scheme used by properly carrying out the self-energy tensor.
The result (38) was also obtained in the work [15] by using massless exact
fermion propagator. We observe that the factor $(e^{2}/16\pi^{2})$, is exactly
the same as found in the well-known Adler-Bell-Jackiw anomaly [20, 21, 22].

##  4 Conclusions

We have investigated the induction of Chern-Simons-like term via quantum
corrections in two different situations. Firstly, we use a same regularization
to different approaches to deal with the exact fermion propagators up to the
leading order in the $b$-coefficient. In this case, our results are finite and
agree with other results in the literature, but they do not agree with each
other, because they are different depending on the approach used. Moreover, it
generates values whose difference is exactly: $\Delta
k_{\beta}=(3e^{2}/{16\pi^{2}})\,b_{\beta}$, which agrees with the result of
Ref. [18] found in another context. We conclude that this is due to the
different approximation of the exact fermion propagator of theory. The problem
was also investigated in a context independent of the approaches used to deal
with the exact fermion propagator. In this case, we modify the derivative
expansion method and obtain a new self-energy tensor for the effective action.
The momentum integrals were calculated by using another regularization scheme.
As a result, we obtained a relation between the coefficients $k_{\beta}$ and
$b_{\beta}$ identical to the one obtained in the case where it was used the
fermion propagator expansion. We also observed that the parameter of
proportionality between these two coefficients is exactly the same as the one
found in the well-known Adler-Bell-Jackiw anomaly. In our calculations, we
also observed that the “noncovariant” contributions for the Chern-Simons-like
term are absent, as was anticipated in [5] in the finite temperature context.
Therefore, we insist that a complete comprehension of these question will
require further investigations.

Acknowledgments. The author would like to thank A. Kostelecký for useful
comments and F.A. Brito for interesting discussions. This work was partially
supported by Conselho Nacional de Desenvolvimento Científico e Tecnológico
(CNPq).

## References

  * [1]
  * [2] S. Carroll, G. Field, R. Jackiw, Phys. Rev. D 41, 1231 (1990).
  * [3] D. Kolladay, V. A. Kostelecký, Phys. Rev. D 55, 6760 (1997).
  * [4] R. Jackiw, Nucl. Phys. Proc. Suppl. 108, 30 (2002), hep-th/0110057.
  * [5] F. A. Brito, J. R. Nascimento, E. Passos, A. Yu. Petrov, JHEP 06, 016 (2007), arXiv: 0705.1338 [hep-th].
  * [6] M. Gomes, J. R. Nascimento, E. Passos, A. Yu. Petrov, A. J. da Silva, Phys. Rev. D 76, 047701 (2007).
  * [7] R. Jackiw, Int. J. Mod. Phys. B 14, 2011 (2000), hep-th/9903044; J. M. Chung, Phys. Rev. D60, 127901 (1999), hep-th/9904037.
  * [8] M. Perez-Victoria, JHEP 04, 032 (2001), hep-th/0102021.
  * [9] G. Bonneau, Nucl. Phys. B 593 (2001) 398.
  * [10] F. A. Brito, J. R. Nascimento, E. Passos, A. Yu. Petrov, arXiv: 0709.3090v2 [hep-th].
  * [11] I. J. R. Aitchison and C. M. Fraser, Phys. Lett. B 146, 63 (1984); Phys. Rev. D 31, 2605 (1985); C. M. Fraser, Z. Phys. C 28, 101 (1985); A. I. Vainshtein, V. I. Zakharov, V. A. Novikov, and M. A. Shifman, Yad. Fiz. (Sov. J. Nucl. Phys.) 39, 77 (1984); J. A. Zuk, Phys. Rev. D 32, 2653 (1985); L.-H. Chan, Phys. Rev. Lett. 54, 1222 (1985); ibid. 55, 21 (1985); M. K. Gaillard, Nucl. Phys. B268, 669 (1986); A. Das and A. Karev, Phys. Rev. D 36, 623 (1987); K. S. Babu, A. Das, and P. Panigrahi, Phys. Rev. D 36, 3725 (1987).
  * [12] D. Ebert, V. Ch. Zhukovsky and A. S. Razumovsky, Phys. Rev. D 70, 025003 (2004).
  * [13] L. Cervi, L. Griguolo, D. Seminara, Phys. Rev. D 64, 105003 (2001).
  * [14] R. Jackiw and V. A. Kostelecký, Phys. Rev. Lett. 82, 3572 (1999), hep-ph/9901358.
  * [15] M. Perez-Victoria, Phys. Rev. Lett. 83 (1999), 2518.
  * [16] G. ‘t Hooft and M. Veltman, Nucl. Phys. B44, 189 (1972).
  * [17] M. Chaichian, W. F. Chen and R. González Filipe, Phys.Lett.B 503, 215-222 (2001).
  * [18] T. Mariz, J. R. Nascimento, E. Passos and R. F. Ribeiro, JHEP 10, 019 (2005).
  * [19] A. A. Andrianov, P. Giacconi and R. Soldati, JHEP 02, 030 (2002).
  * [20] S.L. Adler, Phys. Rev. 177, 2426 (1969); S. L. Adler and W. A Bardeen, Phys. Rev. 182, 1517 (1969); J. S. Bell and R. Jackiw, Nuovo Cimento 60A 47 (1969).
  * [21] Michael E. Peskin and Daniel. V. Schroeder, An Introduction to Quantum Field Theory, Persus Books (1995).
  * [22] H. Banerjee, arXiv: 9907:162 v2 [hep-th].