.. include:: replace.txt

..

	========================================================================================

	Translated for portuguese by the students of the inter-institutional doctorate program of IME-USP/UTFPR-CM.

	Traduzido para o português pelos alunos do programa de doutorado inter institucional do Instituto de Matemática e Estatística da Universidade de São Paulo --- IME-USP em parceria com a Universidade Tecnológica Federal do Paraná - Campus Campo Mourão --- UTFPR-CM:

	* Frank Helbert (frank@ime.usp.br);

	* Luiz Arthur Feitosa dos Santos (luizsan@ime.usp.br);

	* Rodrigo Campiolo (campiolo@ime.usp.br).

	========================================================================================

..

	Tracing

Rastreamento

------------

..

	Background

Introdução

**********

..

	As mentioned in the Using the Tracing System section, the whole point of running

	an |ns3| simulation is to generate output for study.  You have two basic 

	strategies to work with in |ns3|: using generic pre-defined bulk output 

	mechanisms and parsing their content to extract interesting information; or 

	somehow developing an output mechanism that conveys exactly (and perhaps only) 

	the information wanted.

Como abordado na seção Usando o Sistema de Rastreamento, o objetivo principal de uma

simulação no |ns3| é a geração de saída para estudo. Há duas estratégias básicas: 

usar mecanismos predefinidos de saída e processar o conteúdo para extrair informações

relevantes; ou desenvolver mecanismos de saída que resultam somente ou exatamente na

informação pretendida.

..

	Using pre-defined bulk output mechanisms has the advantage of not requiring any

	changes to |ns3|, but it does require programming.  Often, pcap or NS_LOG

	output messages are gathered during simulation runs and separately run through 

	scripts that use grep, sed or awk to parse the messages and reduce and transform

	the data to a manageable form.  Programs must be written to do the 

	transformation, so this does not come for free.  Of course, if the information

	of interest in does not exist in any of the pre-defined output mechanisms,

	this approach fails.

Usar mecanismos predefinidos de saída possui a vantagem de não necessitar modificações 

no |ns3|, mas requer programação. Geralmente, as mensagens de saída do pcap ou ``NS_LOG``

são coletadas durante a execução da simulação e processadas separadamente por códigos (`scripts`) que usam `grep`, `sed` ou `awk` para reduzir e transformar os dados para uma forma mais simples de gerenciar. Há o custo do desenvolvimento de programas para realizar as transformações e em algumas situações a informação de interesse pode não estar contida em nenhuma das saídas, logo, a abordagem falha.

..

	If you need to add some tidbit of information to the pre-defined bulk mechanisms,

	this can certainly be done; and if you use one of the |ns3| mechanisms, 

	you may get your code added as a contribution.

Se precisarmos adicionar o mínimo de informação para os mecanismos predefinidos de saída, isto certamente pode ser feito e se usarmos os mecanismos do |ns3|, podemos

ter nosso código adicionado como uma contribuição.

..

	|ns3| provides another mechanism, called Tracing, that avoids some of the 

	problems inherent in the bulk output mechanisms.  It has several important 

	advantages.  First, you can reduce the amount of data you have to manage by only

	tracing the events of interest to you (for large simulations, dumping everything

	to disk for post-processing can create I/O bottlenecks).  Second, if you use this

	method, you can control the format of the output directly so you avoid the 

	postprocessing step with sed or awk script.  If you desire, your output can be 

	formatted directly into a form acceptable by gnuplot, for example.  You can add 

	hooks in the core which can then be accessed by other users, but which will 

	produce no information unless explicitly asked to do so.  For these reasons, we 

	believe that the |ns3| tracing system is the best way to get information 

	out of a simulation and is also therefore one of the most important mechanisms

	to understand in |ns3|.

O |ns3| fornece outro mecanismo, chamado Rastreamento (*Tracing*), que evita alguns dos

problemas associados com os mecanismos de saída predefinidos. Há várias vantagens. Primeiro, redução da quantidade de dados para gerenciar (em simulações grandes, armazenar toda saída no disco pode gerar gargalos de Entrada/Saída). Segundo, o formato da saída pode ser controlado diretamente evitando o pós-processamento com códigos `sed` ou `awk`. Se desejar,

a saída pode ser processada diretamente para um formato reconhecido pelo `gnuplot`, por exemplo. Podemos adicionar ganchos ("`hooks`") no núcleo, os quais podem ser acessados por outros usuários, mas que não produzirão nenhuma informação exceto que sejam explicitamente solicitados a produzir. Por essas razões, acreditamos que o sistema de rastreamento do |ns3| é a melhor forma de obter informações fora da simulação, portanto é um dos mais importantes mecanismos para ser compreendido no |ns3|.

..

	Blunt Instruments

Métodos Simples

+++++++++++++++

..

	There are many ways to get information out of a program.  The most 

	straightforward way is to just directly print the information to the standard 

	output, as in,

Há várias formas de obter informação após a finalização de um programa. A mais direta

é imprimir a informação na saída padrão, como no exemplo,

::

  #include <iostream>

  ...

  void

  SomeFunction (void)

  {

    uint32_t x = SOME_INTERESTING_VALUE;

    ...

    std::cout << "The value of x is " << x << std::endl;

    ...

  } 

..

	Nobody is going to prevent you from going deep into the core of |ns3| and

	adding print statements.  This is insanely easy to do and, after all, you have 

	complete control of your own |ns3| branch.  This will probably not turn 

	out to be very satisfactory in the long term, though.

Ninguém impedirá que editemos o núcleo do |ns3| e adicionemos códigos de impressão. Isto é simples de fazer, além disso temos controle e acesso total ao código fonte do |ns3|. Entretanto, pensando no futuro, isto não é muito interessante.

..

	As the number of print statements increases in your programs, the task of 

	dealing with the large number of outputs will become more and more complicated.  

	Eventually, you may feel the need to control what information is being printed 

	in some way; perhaps by turning on and off certain categories of prints, or 

	increasing or decreasing the amount of information you want.  If you continue 

	down this path you may discover that you have re-implemented the ``NS_LOG``

	mechanism.  In order to avoid that, one of the first things you might consider

	is using ``NS_LOG`` itself.

Conforme aumentarmos o número de comandos de impressão em nossos programas, ficará mais difícil tratar a grande quantidade de saídas. Eventualmente, precisaremos controlar de alguma maneira qual a informação será impressa; talvez habilitando ou não determinadas categorias de saídas, ou aumentando ou diminuindo a quantidade de informação desejada. Se continuarmos com esse processo, descobriremos depois de um tempo que, reimplementamos o mecanismo ``NS_LOG``. Para evitar isso, utilize o próprio ``NS_LOG``.

..

	We mentioned above that one way to get information out of |ns3| is to 

	parse existing NS_LOG output for interesting information.  If you discover that 

	some tidbit of information you need is not present in existing log output, you 

	could edit the core of |ns3| and simply add your interesting information

	to the output stream.  Now, this is certainly better than adding your own

	print statements since it follows |ns3| coding conventions and could 

	potentially be useful to other people as a patch to the existing core.

Como abordado anteriormente, uma maneira de obter informação de saída do |ns3| é 

processar a saída do ``NS_LOG``, filtrando as informações relevantes. Se a informação

não está presente nos registros existentes, pode-se editar o núcleo do |ns3| e 

adicionar ao fluxo de saída a informação desejada. Claro, isto é muito melhor

que adicionar comandos de impressão, desde que seguindo as convenções de codificação

do |ns3|, além do que isto poderia ser potencialmente útil a outras pessoas.

..

	Let's pick a random example.  If you wanted to add more logging to the 

	|ns3| TCP socket (``tcp-socket-base.cc``) you could just add a new 

	message down in the implementation.  Notice that in TcpSocketBase::ReceivedAck()

	there is no log message for the no ack case.  You could simply add one, 

	changing the code from:

Vamos analisar um exemplo, adicionando mais informações de registro ao `socket` TCP do arquivo ``tcp-socket-base.cc``, para isto vamos acrescentando uma nova mensagem de registro na implementação. Observe que em ``TcpSocketBase::ReceivedAck()`` não existem mensagem de registro para casos sem o *ACK*, então vamos adicionar uma da seguinte forma:

::

  /** Processa o mais recente ACK recebido */

  void

  TcpSocketBase::ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader)

  {

    NS_LOG_FUNCTION (this << tcpHeader);

    // ACK Recebido. Compara o número ACK com o mais alto seqno não confirmado

    if (0 == (tcpHeader.GetFlags () & TcpHeader::ACK))

      { // Ignora se não há flag ACK 

      }

    ...

.. 

	to add a new ``NS_LOG_LOGIC`` in the appropriate statement:

para adicionar um novo ``NS_LOG_LOGIC`` na sentença apropriada:

::

  /** Processa o mais recente ACK recebido */

  void

  TcpSocketBase::ReceivedAck (Ptr<Packet> packet, const TcpHeader& tcpHeader)

  {

    NS_LOG_FUNCTION (this << tcpHeader);

    // ACK Recebido. Compara o número ACK com o mais alto seqno não confirmado

    if (0 == (tcpHeader.GetFlags () & TcpHeader::ACK))

      { // Ignora se não há flag ACK 

        NS_LOG_LOGIC ("TcpSocketBase " << this << " sem flag ACK");

      }

    ...

..

	This may seem fairly simple and satisfying at first glance, but something to

	consider is that you will be writing code to add the ``NS_LOG`` statement 

	and you will also have to write code (as in grep, sed or awk scripts) to parse

	the log output in order to isolate your information.  This is because even 

	though you have some control over what is output by the logging system, you 

	only have control down to the log component level.  

Isto pode parecer simples e satisfatório a primeira vista, mas lembre-se que nós escreveremos

código para adicionar ao ``NS_LOG`` e para processar a saída com a finalidade de isolar

a informação de interesse. Isto porque o controle é limitado ao nível do componente de registro.

..

	If you are adding code to an existing module, you will also have to live with the

	output that every other developer has found interesting.  You may find that in 

	order to get the small amount of information you need, you may have to wade 

	through huge amounts of extraneous messages that are of no interest to you.  You

	may be forced to save huge log files to disk and process them down to a few lines

	whenever you want to do anything.

Se cada desenvolvedor adicionar códigos de saída para um módulo existente, logo conviveremos com a saída que outro desenvolvedor achou interessante. É descobriremos que para obter uma pequena quantidade de informação, precisaremos produzir uma volumosa quantidade de mensagens sem nenhuma relevância (devido aos comandos de saída de vários desenvolvedores). Assim seremos forçados a gerar arquivos de registros gigantescos no disco e processá-los para obter poucas linhas de nosso interesse.

..

	Since there are no guarantees in |ns3| about the stability of ``NS_LOG``

	output, you may also discover that pieces of log output on which you depend 

	disappear or change between releases.  If you depend on the structure of the 

	output, you may find other messages being added or deleted which may affect your

	parsing code.

Como não há nenhuma garantia no |ns3| sobre a estabilidade da saída do ``NS_LOG``, podemos descobrir que partes do registro de saída, que dependíamos, desapareceram ou mudaram entre versões. Se dependermos da estrutura da saída, podemos encontrar outras mensagens sendo adicionadas ou removidas que podem afetar seu código de processamento.

..

	For these reasons, we consider prints to ``std::cout`` and NS_LOG messages 

	to be quick and dirty ways to get more information out of |ns3|.

Por estas razões, devemos considerar o uso do ``std::cout`` e as mensagens ``NS_LOG`` como formas rápidas e porém sujas de obter informação da saída no |ns3|.

..

	It is desirable to have a stable facility using stable APIs that allow one to 

	reach into the core system and only get the information required.  It is

	desirable to be able to do this without having to change and recompile the

	core system.  Even better would be a system that notified the user when an item

	of interest changed or an interesting event happened so the user doesn't have 

	to actively poke around in the system looking for things.

Na grande maioria dos casos desejamos ter um mecanismo estável, usando APIs que permitam acessar o núcleo do sistema e obter somente informações interessantes. Isto deve ser possível sem que exista a necessidade de alterar e recompilar o núcleo do sistema. Melhor ainda seria se um sistema notificasse o usuário quando um item de interesse fora modificado ou um evento de interesse aconteceu, pois o usuário não teria que constantemente vasculhar o sistema procurando por coisas.

..

	The |ns3| tracing system is designed to work along those lines and is 

	well-integrated with the Attribute and Config subsystems allowing for relatively

	simple use scenarios.

O sistema de rastreamento do |ns3| é projetado para trabalhar seguindo essas premissas e é 

integrado com os subsistemas de Atributos (*Attribute*) e Configuração (*Config*) permitindo cenários de uso simples.

.. 

	Overview

Visão Geral

***********

..

	The ns-3 tracing system is built on the concepts of independent tracing sources

	and tracing sinks; along with a uniform mechanism for connecting sources to sinks.

O sistema de rastreamento do |ns3| é baseado no conceito independente origem do rastreamento e destino do rastreamento. O |ns3| utiliza um mecanismo uniforme para conectar origens a destinos.

..

	Trace sources are entities that can signal events that happen in a simulation and 

	provide access to interesting underlying data.  For example, a trace source could

	indicate when a packet is received by a net device and provide access to the 

	packet contents for interested trace sinks.  A trace source might also indicate 

	when an interesting state change happens in a model.  For example, the congestion

	window of a TCP model is a prime candidate for a trace source.

As origens do rastreamento (*trace source*) são entidades que podem assinalar eventos que ocorrem na simulação e fornecem acesso a dados de baixo nível. Por exemplo, uma origem do rastreamento poderia indicar quando um pacote é recebido por um dispositivo de rede e prove acesso ao conteúdo do pacote aos interessados no destino do rastreamento. Uma origem do rastreamento pode também indicar quando uma mudança de estado ocorre em um modelo. Por exemplo, a janela de congestionamento do modelo TCP é um forte candidato para uma origem do rastreamento.

..

	Trace sources are not useful by themselves; they must be connected to other pieces

	of code that actually do something useful with the information provided by the source.

	The entities that consume trace information are called trace sinks.  Trace sources 

	are generators of events and trace sinks are consumers.  This explicit division 

	allows for large numbers of trace sources to be scattered around the system in 

	places which model authors believe might be useful.  

A origem do rastreamento não são úteis sozinhas; elas devem ser conectadas a outras partes de código que fazem algo útil com a informação provida pela origem. As entidades que consomem a informação de rastreamento são chamadas de destino do rastreamento (*trace sinks*). As origens de rastreamento são geradores de eventos e destinos de rastreamento são consumidores. Esta divisão explícita permite que inúmeras origens de rastreamento estejam dispersas no sistema em locais que os autores do modelo acreditam ser úteis.

..

	There can be zero or more consumers of trace events generated by a trace source.  

	One can think of a trace source as a kind of point-to-multipoint information link.  

	Your code looking for trace events from a particular piece of core code could 

	happily coexist with other code doing something entirely different from the same

	information.

Pode haver zero ou mais consumidores de eventos de rastreamento gerados por uma origem do rastreamento. Podemos pensar em uma origem do rastreamento como um tipo de ligação de informação ponto-para-multiponto. Seu código buscaria por eventos de rastreamento de uma parte específica do código do núcleo e poderia coexistir com outro código que faz algo inteiramente diferente com a mesma informação.

..

	Unless a user connects a trace sink to one of these sources, nothing is output.  By

	using the tracing system, both you and other people at the same trace source are 

	getting exactly what they want and only what they want out of the system.  Neither

	of you are impacting any other user by changing what information is output by the 

	system.  If you happen to add a trace source, your work as a good open-source 

	citizen may allow other users to provide new utilities that are perhaps very useful

	overall, without making any changes to the |ns3| core.  

Ao menos que um usuário conecte um destino do rastreamento a uma destas origens, nenhuma saída é produzida. Usando o sistema de rastreamento, todos conectados em uma mesma origem do rastreamento estão obtendo a informação que desejam do sistema. Um usuário não afeta os outros alterando a informação provida pela origem. Se acontecer de adicionarmos uma origem do rastreamento, seu trabalho como um bom cidadão utilizador de código livre pode permitir que outros usuários forneçam novas utilidades para todos, sem fazer qualquer modificação no núcleo do |ns3|.

.. 

	A Simple Low-Level Example

Um Exemplo Simples de Baixo Nível

+++++++++++++++++++++++++++++++++

..

	Let's take a few minutes and walk through a simple tracing example.  We are going

	to need a little background on Callbacks to understand what is happening in the

	example, so we have to take a small detour right away.

Vamos gastar alguns minutos para entender um exemplo de rastreamento simples. Primeiramente

precisamos compreender o conceito de *callbacks* para entender o que está acontecendo

no exemplo.

*Callbacks*

~~~~~~~~~~~

..

	The goal of the Callback system in |ns3| is to allow one piece of code to 

	call a function (or method in C++) without any specific inter-module dependency.

	This ultimately means you need some kind of indirection -- you treat the address

	of the called function as a variable.  This variable is called a pointer-to-function

	variable.  The relationship between function and pointer-to-function pointer is 

	really no different that that of object and pointer-to-object.

O objetivo do sistema de *Callback*, no |ns3|, é permitir a uma parte do código invocar

uma função (ou método em C++) sem qualquer dependência entre módulos. Isto é utilizado para prover algum tipo de indireção -- desta forma tratamos o endereço da chamada de função como uma variável. Esta variável é denominada variável de ponteiro-para-função. O relacionamento entre função e ponteiro-para-função não é tão diferente que de um objeto e ponteiro-para-objeto.

..

	In C the canonical example of a pointer-to-function is a 

	pointer-to-function-returning-integer (PFI).  For a PFI taking one int parameter,

	this could be declared like,

Em C, o exemplo clássico de um ponteiro-para-função é um ponteiro-para-função-retornando-inteiro (PFI). Para um PFI ter um parâmetro inteiro, poderia ser declarado como,

::

  int (*pfi)(int arg) = 0;

..

	What you get from this is a variable named simply "pfi" that is initialized

	to the value 0.  If you want to initialize this pointer to something meaningful,

	you have to have a function with a matching signature.  In this case, you could

	provide a function that looks like,

O código descreve uma variável nomeada como "pfi" que é inicializada com o valor 0. Se quisermos inicializar este ponteiro com um valor significante, temos que ter uma função com uma assinatura idêntica. Neste caso, poderíamos prover uma função como,

::

  int MyFunction (int arg) {}

..

	If you have this target, you can initialize the variable to point to your

	function:

Dessa forma, podemos inicializar a variável apontando para uma função:

::

  pfi = MyFunction;

..

	You can then call MyFunction indirectly using the more suggestive form of

	the call,

Podemos então chamar ``MyFunction`` indiretamente, usando uma forma mais clara da chamada,

::

  int result = (*pfi) (1234);

..

	This is suggestive since it looks like you are dereferencing the function

	pointer just like you would dereference any pointer.  Typically, however,

	people take advantage of the fact that the compiler knows what is going on

	and will just use a shorter form,

É uma forma mais clara, pois é como se estivéssemos dereferenciando o ponteiro da função como dereferenciamos qualquer outro ponteiro. Tipicamente, todavia, usa-se uma forma mais curta pois o compilador sabe o que está fazendo,

::

  int result = pfi (1234);

..

	This looks like you are calling a function named "pfi," but the compiler is

	smart enough to know to call through the variable ``pfi`` indirectly to

	the function ``MyFunction``.

Esta forma é como se estivessemos chamando uma função nomeada "pfi", mas o compilador reconhece que é uma chamada indireta da função ``MyFunction`` por meio da variável ``pfi``.

..

	Conceptually, this is almost exactly how the tracing system will work.

	Basically, a trace source *is* a callback.  When a trace sink expresses

	interest in receiving trace events, it adds a Callback to a list of Callbacks

	internally held by the trace source.  When an interesting event happens, the 

	trace source invokes its ``operator()`` providing zero or more parameters.

	The ``operator()`` eventually wanders down into the system and does something

	remarkably like the indirect call you just saw.  It provides zero or more 

	parameters (the call to "pfi" above passed one parameter to the target function

	``MyFunction``.

Conceitualmente, é quase exatamente como o sistema de rastreamento funciona. Basicamente, uma origem do rastreamento *é* um *callback*. Quando um destino do rastreamento expressa interesse em receber eventos de rastreamento, ela adiciona a *callback* para a lista de *callbacks*  mantida internamente pela origem do rastreamento. Quando um evento de interesse ocorre, a origem do rastreamento invoca seu ``operator()`` provendo zero ou mais parâmetros. O ``operator()`` eventualmente percorre o sistema e faz uma chamada indireta com zero ou mais parâmetros.

..

	The important difference that the tracing system adds is that for each trace

	source there is an internal list of Callbacks.  Instead of just making one 

	indirect call, a trace source may invoke any number of Callbacks.  When a trace

	sink expresses interest in notifications from a trace source, it basically just

	arranges to add its own function to the callback list.

Uma diferença importante é que o sistema de rastreamento adiciona para cada origem do rastreamento uma lista interna de *callbacks*. Ao invés de apenas fazer uma chamada indireta, uma origem do rastreamento pode invocar qualquer número de *callbacks*. Quando um destino do rastreamento expressa interesse em notificações de uma origem, ela adiciona sua própria função para a lista de *callback*.

..

	If you are interested in more details about how this is actually arranged in 

	|ns3|, feel free to peruse the Callback section of the manual.

Estando interessado em mais detalhes sobre como é organizado o sistema de *callback* no |ns3|, leia a seção *Callback* do manual.

.. 

	Example Code

Código de Exemplo

~~~~~~~~~~~~~~~~~

..

	We have provided some code to implement what is really the simplest example

	of tracing that can be assembled.  You can find this code in the tutorial

	directory as ``fourth.cc``.  Let's walk through it.

Analisaremos uma implementação simples de um exemplo de rastreamento. Este código está no diretório do tutorial, no arquivo ``fourth.cc``.

::

  /* -*- Mode:C++; c-file-style:"gnu"; indent-tabs-mode:nil; -*- */

  /*

   * This program is free software; you can redistribute it and/or modify

   * it under the terms of the GNU General Public License version 2 as

   * published by the Free Software Foundation;

   *

   * This program is distributed in the hope that it will be useful,

   * but WITHOUT ANY WARRANTY; without even the implied warranty of

   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   * GNU General Public License for more details.

   *

   * You should have received a copy of the GNU General Public License

   * along with this program; if not, write to the Free Software

   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

   */

  #include "ns3/object.h"

  #include "ns3/uinteger.h"

  #include "ns3/traced-value.h"

  #include "ns3/trace-source-accessor.h"

  #include <iostream>

  using namespace ns3;

..

	Most of this code should be quite familiar to you.  As mentioned above, the

	trace system makes heavy use of the Object and Attribute systems, so you will 

	need to include them.  The first two includes above bring in the declarations

	for those systems explicitly.  You could use the core module header, but this

	illustrates how simple this all really is.  

A maior parte deste código deve ser familiar, pois como já abordado, o sistema de rastreamento faz uso constante dos sistemas Objeto (*Object*) e Atributos (*Attribute*), logo é necessário incluí-los. As duas primeiras inclusões (*include*) declaram explicitamente estes dois sistemas. Poderíamos usar o cabeçalho (*header*) do módulo núcleo, este exemplo é simples.

..

	The file, ``traced-value.h`` brings in the required declarations for tracing

	of data that obeys value semantics.  In general, value semantics just means that

	you can pass the object around, not an address.  In order to use value semantics

	at all you have to have an object with an associated copy constructor and 

	assignment operator available.  We extend the requirements to talk about the set

	of operators that are pre-defined for plain-old-data (POD) types.  Operator=, 

	operator++, operator---, operator+, operator==, etc.

O arquivo ``traced-value.h`` é uma declaração obrigatória para rastreamento de dados que usam passagem por valor. Na passagem por valor é passada uma cópia do objeto e não um endereço. Com a finalidade de usar passagem por valor, precisa-se de um objeto com um construtor de cópia associado e um operador de atribuição. O conjunto de operadores predefinidos para tipos de dados primitivos (*plain-old-data*) são ++, ---, +, ==, etc.

..

	What this all really means is that you will be able to trace changes to a C++

	object made using those operators.

Isto significa que somos capazes de rastrear alterações em um objeto C++ usando estes operadores.

..

	Since the tracing system is integrated with Attributes, and Attributes work

	with Objects, there must be an |ns3| ``Object`` for the trace source

	to live in.  The next code snippet declares and defines a simple Object we can

	work with.

Como o sistema de rastreamento é integrado com Atributos e este trabalham com Objetos, deve obrigatoriamente existir um ``Object`` |ns3| para cada origem do rastreamento. O próximo código define e declara um Objeto.

::

  class MyObject : public Object

  {

  public:

    static TypeId GetTypeId (void)

    {

      static TypeId tid = TypeId ("MyObject")

        .SetParent (Object::GetTypeId ())

        .AddConstructor<MyObject> ()

        .AddTraceSource ("MyInteger",

                         "An integer value to trace.",

                         MakeTraceSourceAccessor (&MyObject::m_myInt))

        ;

      return tid;

    }

    MyObject () {}

    TracedValue<int32_t> m_myInt;

  };

..

	The two important lines of code, above, with respect to tracing are the 

	``.AddTraceSource`` and the ``TracedValue`` declaration of ``m_myInt``.

As duas linhas mais importantes com relação ao rastreamento são ``.AddTraceSource`` e a declaração ``TracedValue`` do ``m_myInt``.

..

	The ``.AddTraceSource`` provides the "hooks" used for connecting the trace

	source to the outside world through the config system.  The ``TracedValue`` 

	declaration provides the infrastructure that overloads the operators mentioned 

	above and drives the callback process.

O método ``.AddTraceSource`` provê a "ligação" usada para conectar a origem do rastreamento com o mundo externo, por meio do sistema de configuração. A declaração ``TracedValue`` provê a infraestrutura que sobrecarrega os operadores abordados anteriormente e  gerencia o processo de *callback*.

::

  void

  IntTrace (int32_t oldValue, int32_t newValue)

  {

    std::cout << "Traced " << oldValue << " to " << newValue << std::endl;