simulator-pool.cpp

#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdio>
#include <map>
#include <set>
#include <vector>
#include <deque>
#include <string>
#include <utility>
// TODO #include <stxxl/map>

using namespace std;

#include "tokenizer.h"
#include "classinfo.h"
#include "execution.h"
#include "heap.h"
#include "refstate.h"
#include "summary.hpp"
// #include "lastmap.h"
#include "version.hpp"
#include "MemoryPool.hpp"

// // STXXL related constants
// #define DATA_NODE_BLOCK_SIZE (4096)
// #define DATA_LEAF_BLOCK_SIZE (4096)

// ----------------------------------------------------------------------
// Types
class Object;
class CCNode;

typedef std::map< string, std::vector< Summary * > > GroupSum_t;
typedef std::map< string, Summary * > TypeTotalSum_t;
typedef std::map< unsigned int, Summary * > SizeSum_t;

// An Edge Source is an object and it's specific field.
// Global edge sources have a NULL object pointer.
typedef std::pair< Object *, FieldId_t > EdgeSrc_t; 
// ----------------------------------------------------------------------
// We then map Edge Sources to a vector/list of Object pointers.
// For every edge source, we keep a list of all the objects (pointers)
// it has ever pointed to.
// This is the in-memory stl version
typedef std::map< EdgeSrc_t, std::vector< Object * > > EdgeSummary_t;
// We need a reverse map from object pointer to the edge sources that ever
// pointed to that object.
typedef std::map< Object *, std::vector< EdgeSrc_t > > Object2EdgeSrcMap_t;

// Trying an on-disk version but the library I DLed doesn't work well with C++11
// TODO //! [comparator]
// TODO struct CompareGreater_EdgeSummary
// TODO {
// TODO bool operator () (const EdgeSrc_t &a, const EdgeSrc_t &b) const {
// TODO Object *first = std::get<0>(a); 
// TODO Object *second = std::get<0>(b); 
// TODO if (first != second) {
// TODO return first > second;
// TODO } else {
// TODO FieldId_t field1 = std::get<1>(a); 
// TODO FieldId_t field2 = std::get<1>(b); 
// TODO return field1 > field2;
// TODO }
// TODO }
// TODO static EdgeSrc_t max_value() {
// TODO return std::make_pair( static_cast<Object *>(NULL),
// TODO std::numeric_limits<unsigned int>::min() );
// TODO }
// TODO };
// TODO //! [comparator]
// TODO // This is the out-of-core (on-disk) version.
// TODO typedef stxxl::map< EdgeSrc_t, std::vector< Object * >,
// TODO CompareGreater_EdgeSummary,
// TODO DATA_NODE_BLOCK_SIZE, DATA_LEAF_BLOCK_SIZE >
// TODO stxxl_EdgeSummary_t;
// TODO // TODO: This is just dummy code to test the STXXL compilation units.
// TODO // Need to replace EdgeSummary_t with the stxxl::map. (Or maybe make it configurable)
// TODO // TODO: Test
// TODO typedef stxxl_EdgeSummary_t EdgeSummary_t;
// TODO 
// TODO //! [comparator]
// TODO struct CompareGreater
// TODO {
// TODO bool operator () (const int & a, const int & b) const {
// TODO return a > b;
// TODO }
// TODO static int max_value() {
// TODO return std::numeric_limits<int>::min();
// TODO }
// TODO };
// TODO //! [comparator]
// TODO // This is the out-of-core (on-disk) version.
// TODO //! [comparator]
// TODO typedef stxxl::map<int, char, CompareGreater, DATA_NODE_BLOCK_SIZE, DATA_LEAF_BLOCK_SIZE> stxxl_Object2EdgeSrcMap_t;


// EdgeSummary_t and Object2EdgeSrcMap_t contain the raw data. We need some
// summaries.
// enum class ObjectRefType moved to heap.h - RLV

enum class EdgeSrcType {
 STABLE = 1, // Like True Love. Only one target ever.
 // TODO: This is an original idea that maybe singly-owned objects
 // can be considered part of the stable group.
 SERIAL_STABLE = 2, // Kind of like a serial monogamist.
 // Can point to different objects but never shares the
 // target object
 UNSTABLE = 32, // Points to different objects and
 // shares objects with other references
 UNKNOWN = 1024
};

string edgesrctype2str( EdgeSrcType r)
{
 if (r == EdgeSrcType::STABLE) {
 return "STABLE";
 } else if (r == EdgeSrcType::SERIAL_STABLE) {
 return "SERIAL_STABLE";
 } else if (r == EdgeSrcType::UNSTABLE) {
 return "UNSTABLE";
 } else {
 return "UNKNOWN";
 }
}

string edgesrctype2shortstr( EdgeSrcType r)
{
 if (r == EdgeSrcType::STABLE) {
 return "S"; // STABLE
 } else if (r == EdgeSrcType::SERIAL_STABLE) {
 return "ST"; // SERIAL_STABLE
 } else if (r == EdgeSrcType::UNSTABLE) {
 return "U"; // UNSTABLE
 } else {
 return "X"; // UNKNOWN
 }
}

// Map a reference to its type
typedef std::map< EdgeSrc_t, EdgeSrcType > EdgeSrc2Type_t;
// Map an object to its type
// TODO: Is this needed?
typedef std::map< Object *, ObjectRefType > Object2Type_t;

// ----------------------------------------------------------------------
// Globals

// -- Key object map to set of objects
KeySet_t keyset;
// -- Object to key object map
ObjectPtrMap_t whereis;

// -- The heap
HeapState Heap( whereis, keyset );

// -- Execution state
#ifdef ENABLE_TYPE1
ExecMode cckind = ExecMode::Full; // Full calling context
#else
ExecMode cckind = ExecMode::StackOnly; // Stack-only context
#endif // ENABLE_TYPE1

ExecState Exec(cckind);

// -- Turn on debugging
bool debug = false;

// -- Remember the last event by thread ID
// TODO: Types for object and thread IDs?
// TODO LastMap last_map;

// ----------------------------------------------------------------------
// Analysis
deque< deque<Object*> > cycle_list;
set<unsigned int> root_set;

map<unsigned int, unsigned int> deathrc_map;
map<unsigned int, bool> not_candidate_map;

EdgeSummary_t edge_summary;
Object2EdgeSrcMap_t obj2ref_map;


// ----------------------------------------------------------------------
void sanity_check()
{
/*
 if (Now > obj->getDeathTime() && obj->getRefCount() != 0) {
 nonzero_ref++;
 printf(" Non-zero-ref-dead %X of type %s\n", obj->getId(), obj->getType().c_str());
 }
 */
}

bool member( Object* obj, const ObjectSet& theset )
{
 return theset.find(obj) != theset.end();
}

unsigned int closure( ObjectSet& roots,
 ObjectSet& premarked,
 ObjectSet& result )
{
 unsigned int mark_work = 0;

 vector<Object*> worklist;

 // -- Initialize the worklist with only unmarked roots
 for ( ObjectSet::iterator i = roots.begin();
 i != roots.end();
 i++ ) {
 Object* root = *i;
 if ( !member(root, premarked) ) {
 worklist.push_back(root);
 }
 }

 // -- Do DFS until the worklist is empty
 while (worklist.size() > 0) {
 Object* obj = worklist.back();
 worklist.pop_back();
 result.insert(obj);
 mark_work++;

 const EdgeMap& fields = obj->getFields();
 for ( EdgeMap::const_iterator p = fields.begin();
 p != fields.end();
 p++ ) {
 Edge* edge = p->second;
 Object* target = edge->getTarget();
 if (target) {
 // if (target->isLive(Exec.NowUp())) {
 if ( !member(target, premarked) &&
 !member(target, result) ) {
 worklist.push_back(target);
 }
 // } else {
 // cout << "WEIRD: Found a dead object " << target->info() << " from " << obj->info() << endl;
 // }
 }
 }
 }

 return mark_work;
}

unsigned int count_live( ObjectSet & objects, unsigned int at_time )
{
 int count = 0;
 // -- How many are actually live
 for ( ObjectSet::iterator p = objects.begin();
 p != objects.end();
 p++ ) {
 Object* obj = *p;
 if (obj->isLive(at_time)) {
 count++;
 }
 }

 return count;
}

void update_reference_summaries( Object *src,
 FieldId_t fieldId,
 Object *tgt )
{
 // edge_summary : EdgeSummary_t is a global
 // obj2ref_map : Object2EdgeSrcMap_t is a global
 EdgeSrc_t ref = std::make_pair( src, fieldId );
 // The reference 'ref' points to the new target
 auto iter = edge_summary.find(ref);
 if (iter == edge_summary.end()) {
 // Not found. Create a new vector of Object pointers
 edge_summary[ref] = std::vector< Object * >();
 }
 edge_summary[ref].push_back(tgt);
 // Do the reverse mapping ONLY if tgt is not NULL
 if (tgt) {
 auto rev = obj2ref_map.find(tgt);
 if (rev == obj2ref_map.end()) {
 obj2ref_map[tgt] = std::move(std::vector< EdgeSrc_t >());
 }
 obj2ref_map[tgt].push_back(ref);
 }
}

// ----------------------------------------------------------------------
// Read and process trace events
void apply_merlin( std::deque< Object * > &new_garbage )
{
 if (new_garbage.size() == 0) { 
 // TODO Log an ERROR or a WARNING
 return;
 }
 // TODO: Use setDeathTime( new_dtime );
 // Sort the new_garbage vector according to latest last_timestamp.
 std::sort( new_garbage.begin(),
 new_garbage.end(),
 []( Object *left, Object *right ) {
 return (left->getLastTimestamp() > right->getLastTimestamp());
 } );
 // Do a standard DFS.
 while (new_garbage.size() > 0) {
 // Start with the latest for the DFS.
 Object *cur = new_garbage[0];
 new_garbage.pop_front();
 std::deque< Object * > mystack; // stack for DFS
 std::set< Object * > labeled; // What Objects have been labeled
 mystack.push_front( cur );
 while (mystack.size() > 0) {
 Object *otmp = mystack[0];
 mystack.pop_front();
 assert(otmp);
 // The current timestamp max
 unsigned int tstamp_max = otmp->getLastTimestamp();
 otmp->setDeathTime( tstamp_max );
 // Remove from new_garbage deque
 auto ngiter = std::find( new_garbage.begin(),
 new_garbage.end(),
 otmp );
 if (ngiter != new_garbage.end()) {
 // still in the new_garbage deque
 new_garbage.erase(ngiter);
 }
 // Check if labeled already
 auto iter = labeled.find(otmp);
 if (iter == labeled.end()) {
 // Not found => not labeled

 labeled.insert(otmp);
 // Go through all the edges out of otmp
 // -- Visit all edges
 for ( auto ptr = otmp->getFields().begin();
 ptr != otmp->getFields().end();
 ptr++ ) {
 Edge *edge = ptr->second;
 if ( edge &&
 ((edge->getEdgeState() == EdgeState::DEAD_BY_OBJECT_DEATH) ||
 (edge->getEdgeState() == EdgeState::DEAD_BY_OBJECT_DEATH_NOT_SAVED)) ) {
 edge->setEndTime( tstamp_max );
 Object *mytgt = edge->getTarget();
 if (mytgt) {
 // Get timestamp
 unsigned int tstmp = mytgt->getLastTimestamp();
 if (tstamp_max > tstmp) {
 mytgt->setLastTimestamp( tstamp_max );
 mytgt->setDeathTime( tstamp_max );
 }
 // This might be a bug. I probably shouldn't be setting the tstamp_max here.
 // But then again where should it be set? It seems that this is the right thing
 // to do here.
 // TODO else {
 // TODO tstamp_max = tstmp;
 // TODO }
 mystack.push_front( mytgt );
 }
 }
 }
 }
 }
 }
 // Until the vector is empty
}

// ----------------------------------------------------------------------
// Read and process trace events
unsigned int read_trace_file( FILE *f,
 ofstream &eifile,
 MemoryPool<Object, 1342177280> &objpool,
 MemoryPool<Edge, 1342177280> &edgepool )
{
 // eifile is the edge_info_file
 Tokenizer tokenizer(f);

 // Memory pool allocator for Objects

 unsigned int method_id;
 unsigned int object_id;
 unsigned int target_id;
 unsigned int field_id;
 unsigned int thread_id;
 unsigned int exception_id;
 Object *obj;
 Object *target;
 Method *method;
 unsigned int total_objects = 0;

 // Remember all the dead objects
 std::deque< Object * > new_garbage;
 Method *main_method = ClassInfo::get_main_method();
 unsigned int main_id = main_method->getId();

 unsigned int latest_death_time = 0;

 // DEBUG
 unsigned int debug_stack_edges = 0;
 // END DEBUG
 // -- Allocation time
 unsigned int AllocationTime = 0;
 while ( ! tokenizer.isDone()) {
 tokenizer.getLine();
 if (tokenizer.isDone()) {
 break;
 }

 if (Exec.NowUp() % 1050000 == 1) {
 // cout << " Method time: " << Exec.Now() << " Alloc time: " << AllocationTime << endl;
 cout << " Update time: " << Exec.NowUp() << " | Method time: TODO | Alloc time: " << AllocationTime << endl;
 }

 switch (tokenizer.getChar(0)) {
 case 'A':
 case 'I':
 case 'N':
 case 'P':
 case 'V':
 {
 // A/I/N/P/V <id> <size> <type> <site> [<els>] <threadid>
 // 0 1 2 3 4 5 5/6
 unsigned int thrdid = (tokenizer.numTokens() == 6) ? tokenizer.getInt(6)
 : tokenizer.getInt(5);
 Thread* thread = Exec.getThread(thrdid);
 unsigned int els = (tokenizer.numTokens() == 6) ? tokenizer.getInt(5)
 : 0;
 AllocSite *as = ClassInfo::TheAllocSites[tokenizer.getInt(4)];
 // TODO TODO FIX THIS WITH THE NONJLIB CALL. see simulator.cpp
 string njlib_sitename("TODO");
 assert(false); // FIX ME TODO FIX ME TODO 2017-Feb-20 - RLV
 assert(thread);
 // TODO: // Get context pair
 // TODO: ContextPair cpair = thread->getContextPair();
 // TODO: CPairType cptype = thread->getContextPairType();
 // DEBUG
 // if (!as) {
 // cerr << "DBG: objId[ " << tokenizer.getInt(1) << " ] has no alloc site." << endl;
 // } // END DEBUG
 // TODO: obj = Heap.allocate( tokenizer.getInt(1), // id
 // TODO: tokenizer.getInt(2), // size
 // TODO: tokenizer.getChar(0), // kind of alloc
 // TODO: tokenizer.getString(3), // type
 // TODO: as, // AllocSite pointer
 // TODO: els, // length IF applicable
 // TODO: thread, // thread Id
 // TODO: Exec.NowUp() ); // Current time
 obj = objpool.newElement( tokenizer.getInt(1), // id
 tokenizer.getInt(2), // size
 tokenizer.getChar(0), // kind of alloc
 tokenizer.getString(3), // type
 as, // AllocSite pointer
 njlib_sitename, // Non Javalib alloc sitename
 els, // length IF applicable
 thread, // thread Id
 Exec.NowUp(),
 &Heap ); // Current time
 Heap.allocate( obj );
#ifdef _SIZE_DEBUG
		 cout << "OS: " << sizeof(*obj) << endl;
#endif // _SIZE_DEBUG
 AllocationTime = Heap.getAllocTime();
 Exec.SetAllocTime( AllocationTime );
 if (as) {
 Exec.UpdateObj2AllocContext( obj,
 as->getMethod()->getName() );
 } else {
 Exec.UpdateObj2AllocContext( obj,
 "NOSITE" );
 }
 if (cckind == ExecMode::Full) {
 // Get full stacktrace
 DequeId_t strace = thread->stacktrace_using_id();
 obj->setAllocContextList( strace );
 }
 total_objects++;
 }
 break;

 case 'U':
 {
 // U <old-target> <object> <new-target> <field> <thread>
 // 0 1 2 3 4 5
 // -- Look up objects and perform update
 unsigned int objId = tokenizer.getInt(2);
 unsigned int tgtId = tokenizer.getInt(3);
 unsigned int oldTgtId = tokenizer.getInt(1);
 unsigned int threadId = tokenizer.getInt(5);
 unsigned int field = tokenizer.getInt(4);
 Thread *thread = Exec.getThread(threadId);
 Object *oldObj = Heap.getObject(oldTgtId);
 LastEvent lastevent = LastEvent::UPDATE_UNKNOWN;
 Exec.IncUpdateTime();
 obj = Heap.getObject(objId);
 // NOTE that we don't need to check for non-NULL source object 'obj'
 // here. NULL means that it's a global/static reference.
 target = ((tgtId > 0) ? Heap.getObject(tgtId) : NULL);
 if (obj) {
 update_reference_summaries( obj, field, target );
 }
 // TODO last_map.setLast( threadId, LastEvent::UPDATE, obj );
 // Set lastEvent and heap/stack flags for new target
 if (target) {
 if ( obj && 
 obj != target
 /* && !(obj->wasRoot())
 * NOTE: This was the original code which in resulted
 * in LESS Died By STACK after HEAP. Making this change
 * to see if the results match the intuition of the code
 * being analyzed. - RLV 2017 Feb 16
 * */
 ) {
 target->setPointedAtByHeap();
 }
 target->setLastTimestamp( Exec.NowUp() );
 // TODO: target->setActualLastTimestamp( Exec.NowUp() );
 // TODO: Maybe LastUpdateFromStatic isn't the most descriptive
 // So since target has an incoming edge, LastUpdateFromStatic
 // should be FALSE.
 target->unsetLastUpdateFromStatic();
 }
 // Set lastEvent and heap/stack flags for old target
 if (oldObj) {
 // Set the last time stamp for Merlin Algorithm purposes
 oldObj->setLastTimestamp( Exec.NowUp() );
 oldObj->setActualLastTimestamp( Exec.NowUp() );
 // Keep track of other properties
 if (tgtId != 0) {
 oldObj->unsetLastUpdateNull();
 } else {
 oldObj->setLastUpdateNull();
 }
 if (target) {
 if (oldTgtId != tgtId) {
 lastevent = LastEvent::UPDATE_AWAY_TO_VALID;
 oldObj->setLastEvent( lastevent );
 }
 } else {
 // There's no need to check for oldTgtId == tgtId here.
 lastevent = LastEvent::UPDATE_AWAY_TO_NULL;
 oldObj->setLastEvent( lastevent );
 }
 if (field == 0) {
 oldObj->setLastUpdateFromStatic();
 } else {
 oldObj->unsetLastUpdateFromStatic();
 }
 }
 if (oldTgtId == tgtId) {
 // It sometimes happens that the newtarget is the same as
 // the old target. So we won't create any more new edges.
 // DEBUG: cout << "UPDATE same new == old: " << target << endl;
 } else {
 if (obj) {
 Edge *new_edge = NULL;
 // Can't call updateField if obj is NULL
 if (target) {
 // Increment and decrement refcounts
 unsigned int field_id = tokenizer.getInt(4);
 // TODO: new_edge = Heap.make_edge( obj, field_id,
 // TODO: target, Exec.NowUp() );
 new_edge = edgepool.newElement( obj,
 field_id,
 target,
 Exec.NowUp() );
 Heap.make_edge( new_edge );
#ifdef _SIZE_DEBUG
				cout << "ES: " << sizeof(*new_edge) << endl;
#endif // _SIZE_DEBUG
 }
 Method *topMethod = NULL;
 if (thread) {
 topMethod = thread->TopMethod();
 }
 obj->updateField( new_edge,
 field_id,
 Exec.NowUp(),
 topMethod, // for death site info
 Reason::HEAP, // reason
 NULL, // death root 0 because may not be a root
 lastevent, // last event to determine cause
 EdgeState::DEAD_BY_UPDATE, // edge is dead because of update
 eifile ); // output edge info file
 // NOTE: topMethod COULD be NULL here.
 // DEBUG ONLY IF NEEDED
 // Example:
 // if ( (objId == tgtId) && (objId == 166454) ) {
 // if ( (objId == 166454) ) {
 // tokenizer.debugCurrent();
 // }
 }
 }
 }
 break;

 case 'D':
 {
 // D <object> <thread-id>
 // 0 1 2
 unsigned int objId = tokenizer.getInt(1);
 obj = Heap.getObject(objId);
 if (obj) {
 unsigned int now_uptime = Exec.NowUp();
 // Merlin algorithm portion. TODO: This is getting unwieldy. Think about
 // refactoring.
 // Keep track of the latest death time
 // TODO: Debug? Well it's a decent sanity check so we may leave it in.
 assert( latest_death_time <= now_uptime );
 // Ok, so now we can see if the death time has 
 if (now_uptime > latest_death_time) {
 // Do the Merlin algorithm
 apply_merlin( new_garbage );
 // TODO: What are the parameters?
 // - new_garbage for sure
 // - anything else?
 // For now this simply updates the object death times
 }
 // Update latest death time
 latest_death_time = now_uptime;

 // The rest of the bookkeeping
 new_garbage.push_back(obj);
 unsigned int threadId = tokenizer.getInt(2);
 LastEvent lastevent = obj->getLastEvent();
 // Set the died by flags
 if ( (lastevent == LastEvent::UPDATE_AWAY_TO_NULL) ||
 (lastevent == LastEvent::UPDATE_AWAY_TO_VALID) ||
 (lastevent == LastEvent::UPDATE_UNKNOWN) ) {
 if (obj->wasLastUpdateFromStatic()) {
 obj->setDiedByGlobalFlag();
 }
 // Design decision: all died by globals are
 // also died by heap.
 obj->setDiedByHeapFlag();
 } else if ( (lastevent == LastEvent::ROOT) ||
 (lastevent == LastEvent::OBJECT_DEATH_AFTER_ROOT_DECRC) ||
 (lastevent == LastEvent::OBJECT_DEATH_AFTER_UPDATE_DECRC) ) {
 obj->setDiedByStackFlag();
 }
 //else {
 // cerr << "Unhandled event: " << lastevent2str(lastevent) << endl;
 // }
 Heap.makeDead( obj,
 now_uptime,
 eifile );
 // Get the current method
 Method *topMethod = NULL;
 MethodDeque top_2_methods;
 MethodDeque javalib_context;
 // TODO: ContextPair cpair;
 CPairType cptype;
 Thread *thread;
 if (threadId > 0) {
 thread = Exec.getThread(threadId);
 // Update counters in ExecState for map of
 // Object * to simple context pair
 } else {
 // No thread info. Get from ExecState
 thread = Exec.get_last_thread();
 }
 if (thread) {
 // TODO: cpair = thread->getContextPair();
 // TODO: cptype = thread->getContextPairType();
 unsigned int count = 0;
 topMethod = thread->TopMethod();
 // top_2_methods = thread->top_N_methods(2);
 javalib_context = thread->top_javalib_methods();
 if (cckind == ExecMode::Full) {
 // Get full stacktrace
 DequeId_t strace = thread->stacktrace_using_id();
 obj->setDeathContextList( strace );
 }
 // Set the death site
 Exec.UpdateObj2DeathContext( obj,
 javalib_context );
 // TODO DELETE if (topMethod) {
 // TODO DELETE obj->setDeathSite(topMethod);
 // TODO DELETE Exec.UpdateObj2DeathContext( obj,
 // TODO DELETE topMethod->getName() );
 // TODO DELETE } else {
 // TODO DELETE Exec.UpdateObj2DeathContext( obj,
 // TODO DELETE "NULL_METHOD" );
 // TODO DELETE }
 // Death reason setting
 Reason myreason;
 if (thread->isLocalVariable(obj)) {
 myreason = Reason::STACK;
 } else {
 myreason = Reason::HEAP;
 }
 // Recursively make the edges dead and assign the proper death cause
 for ( EdgeMap::iterator p = obj->getEdgeMapBegin();
 p != obj->getEdgeMapEnd();
 ++p ) {
 Edge* target_edge = p->second;
 if (target_edge) {
 unsigned int fieldId = target_edge->getSourceField();
 obj->updateField( NULL,
 fieldId,
 Exec.NowUp(),
 topMethod,
 myreason,
 obj,
 lastevent,
 EdgeState::DEAD_BY_OBJECT_DEATH_NOT_SAVED,
 eifile ); // output edge info file
 // NOTE: STACK is used because the object that died,
 // died by STACK.
 }
 }
 } // if (thread)
 unsigned int rc = obj->getRefCount();
 deathrc_map[objId] = rc;
 not_candidate_map[objId] = (rc == 0);
 } else {
 assert(false);
 } // if (obj) ... else
 }
 break;

 case 'M':
 {
 // M <methodid> <receiver> <threadid>
 // 0 1 2 3
 // current_cc = current_cc->DemandCallee(method_id, object_id, thread_id);
 // TEMP TODO ignore method events
 method_id = tokenizer.getInt(1);
 method = ClassInfo::TheMethods[method_id];
 thread_id = tokenizer.getInt(3);
 // Check to see if this is the main function
 if (method == main_method) {
 Exec.set_main_func_uptime( Exec.NowUp() );
 Exec.set_main_func_alloctime( Exec.NowAlloc() );
 }
 Exec.Call(method, thread_id);
 }
 break;

 case 'E':
 case 'X':
 {
 // E <methodid> <receiver> [<exceptionobj>] <threadid>
 // 0 1 2 3 3/4
 method_id = tokenizer.getInt(1);
 method = ClassInfo::TheMethods[method_id];
 thread_id = (tokenizer.numTokens() == 4) ? tokenizer.getInt(3)
 : tokenizer.getInt(4);
 Exec.Return(method, thread_id);
 }
 break;

 case 'T':
 // T <methodid> <receiver> <exceptionobj>
 // 0 1 2 3
 break;

 case 'H':
 // H <methodid> <receiver> <exceptionobj>
 break;

 case 'R':
 // R <objid> <threadid>
 // 0 1 2
 {
 unsigned int objId = tokenizer.getInt(1);
 Object *object = Heap.getObject(objId);
 unsigned int threadId = tokenizer.getInt(2);
 // cout << "objId: " << objId << " threadId: " << threadId << endl;
 if (object) {
 object->setRootFlag(Exec.NowUp());
 object->setLastEvent( LastEvent::ROOT );
 object->setLastTimestamp( Exec.NowUp() );
 object->setActualLastTimestamp( Exec.NowUp() );
 Thread *thread = Exec.getThread(threadId);
 if (thread) {
 thread->objectRoot(object);
 }
 }
 root_set.insert(objId);
 // TODO last_map.setLast( threadId, LastEvent::ROOT, object );
 }
 break;

 default:
 // cout << "ERROR: Unknown entry " << tokenizer.curChar() << endl;
 break;
 }
 }
 cout << "DEBUG_STACK_EDGES: " << debug_stack_edges << endl;
 return total_objects;
}

// ----------------------------------------------------------------------
// Remove edges not in cyclic garbage
void filter_edgelist( deque< pair<int,int> >& edgelist, deque< deque<int> >& cycle_list )
{
 set<int> nodes;
 deque< pair<int,int> > newlist;
 for ( auto it = cycle_list.begin();
 it != cycle_list.end();
 ++it ) {
 for ( auto tmp = it->begin();
 tmp != it->end();
 ++tmp ) {
 nodes.insert(*tmp);
 }
 }
 for ( auto it = edgelist.begin();
 it != edgelist.end();
 ++it ) {
 auto first_it = nodes.find(it->first);
 if (first_it == nodes.end()) {
 // First node not found, carry on.
 continue;
 }
 auto second_it = nodes.find(it->second);
 if (second_it != nodes.end()) {
 // Found both edge nodes in cycle set 'nodes'
 // Add the edge.
 newlist.push_back(*it);
 }
 }
 edgelist = newlist;
}

unsigned int sumSize( std::set< Object * >& s )
{
 unsigned int total = 0;
 for ( auto it = s.begin();
 it != s.end();
 ++it ) {
 total += (*it)->getSize();
 }
 return total;
}

void update_summaries( Object *key,
 std::set< Object * >& tgtSet,
 GroupSum_t& pgs,
 TypeTotalSum_t& tts,
 SizeSum_t& ssum )
{
 string mytype = key->getType();
 unsigned gsize = tgtSet.size();
 // per group summary
 auto git = pgs.find(mytype);
 if (git == pgs.end()) {
 pgs[mytype] = std::move(std::vector< Summary * >());
 }
 unsigned int total_size = sumSize( tgtSet );
 Summary *s = new Summary( gsize, total_size, 1 );
 // -- third parameter is number of groups which is simply 1 here.
 pgs[mytype].push_back(s);
 // type total summary
 auto titer = tts.find(mytype);
 if (titer == tts.end()) {
 Summary *t = new Summary( gsize, total_size, 1 );
 tts[mytype] = t;
 } else {
 tts[mytype]->size += total_size;
 tts[mytype]->num_objects += tgtSet.size();
 tts[mytype]->num_groups++;
 }
 // size summary
 auto sit = ssum.find(gsize);
 if (sit == ssum.end()) {
 Summary *u = new Summary( gsize, total_size, 1 );
 ssum[gsize] = u;
 } else {
 ssum[gsize]->size += total_size;
 ssum[gsize]->num_groups++;
 // Doesn't make sense to make use of the num_objects field.
 }
}

void update_summary_from_keyset( KeySet_t &keyset,
 GroupSum_t &per_group_summary,
 TypeTotalSum_t &type_total_summary,
 SizeSum_t &size_summary )
{
 for ( auto it = keyset.begin();
 it != keyset.end();
 ++it ) {
 Object *key = it->first;
 std::set< Object * > *tgtSet = it->second;
 // TODO TODO 7 March 2016 - Put into CSV file.
 cout << "[ " << key->getType() << " ]: " << tgtSet->size() << endl;
 update_summaries( key,
 *tgtSet,
 per_group_summary,
 type_total_summary,
 size_summary );
 }
}


void summarize_reference_stability( EdgeSrc2Type_t &stability,
 EdgeSummary_t &my_refsum,
 Object2EdgeSrcMap_t &my_obj2ref )
{
 // Check each object to see if it's stable...(see ObjectRefType)
 for ( auto it = my_obj2ref.begin();
 it != my_obj2ref.end();
 ++it ) {
 // my_obj2ref : Object2EdgeSrcMap_t is a reverse map of sorts.
 // For each object in the map, it maps to a vector of references
 // that point/refer to that object
 // This Object is the target
 Object *obj = it->first;
 // This is the vector of references
 std::vector< EdgeSrc_t > reflist = it->second;
 // Convert to a set in order to remove possible duplicates
 std::set< EdgeSrc_t > refset( reflist.begin(), reflist.end() );
 if (!obj) {
 continue;
 }
 // obj is not NULL.
 // if ( (refset.size() <= 1) && (obj->wasLastUpdateNull() != true) ) {
 if (refset.size() <= 1) {
 obj->setRefTargetType( ObjectRefType::SINGLY_OWNED );
 } else {
 obj->setRefTargetType( ObjectRefType::MULTI_OWNED );
 }
 }
 // Check each edge source to see if its stable...(see EdgeSrcType)
 for ( auto it = my_refsum.begin();
 it != my_refsum.end();
 ++it ) {
 // my_refsum : EdgeSummary_t is a map from reference to a vector of
 // objects that the reference pointed to. A reference is a pair
 // of (Object pointer, fieldId).
 // Get the reference and deconstruct into parts.
 EdgeSrc_t ref = it->first;
 Object *obj = std::get<0>(ref); 
 FieldId_t fieldId = std::get<1>(ref); 
 // Get the vector/list of object pointers
 std::vector< Object * > objlist = it->second;
 // We need to make sure that all elements are not duplicates.
 std::set< Object * > objset( objlist.begin(), objlist.end() );
 // Is NULL in there?
 auto findit = objset.find(NULL);
 bool nullflag = (findit != objset.end());
 if (nullflag) {
 // If NULL is in the list, remove NULL.
 objset.erase(findit);
 }
 unsigned int size = objset.size();
 if (size == 1) {
 // The reference only points to one object!
 // Convert object set back into a vector.
 std::vector< Object * > tmplist( objset.begin(), objset.end() );
 assert( tmplist.size() == 1 );
 Object *tgt = tmplist[0];
 // Check for source and target death times
 // The checks for NULL are probably NOT necessary.
 assert(obj != NULL);
 VTime_t src_dtime = obj->getDeathTime();
 assert(tgt != NULL);
 VTime_t tgt_dtime = tgt->getDeathTime();
 if (tgt_dtime != src_dtime) {
 // UNSTABLE if target and source deathtimes are different
 // NOTE: This used to be UNSTABLE if target died before source.
 // We are using a more conservative definition of stability here.
 stability[ref] = EdgeSrcType::UNSTABLE;
 } else {
 stability[ref] = (tgt->wasLastUpdateNull() ? EdgeSrcType::UNSTABLE : EdgeSrcType::STABLE);
 }
 } else {
 // objlist is of length > 1
 // This may still be stable if all objects in
 // the list are STABLE. Assume they're all stable unless
 // otherwise proven.
 stability[ref] = EdgeSrcType::SERIAL_STABLE; // aka serial monogamist
 for ( auto objit = objset.begin();
 objit != objset.end();
 ++objit ) {
 ObjectRefType objtype = (*objit)->getRefTargetType();
 if (objtype == ObjectRefType::MULTI_OWNED) {
 stability[ref] = EdgeSrcType::UNSTABLE;
 break;
 } else if (objtype == ObjectRefType::UNKNOWN) {
 // Not sure if this is even possible.
 // TODO: Make this an assertion?
 // Let's assume that UNKNOWNs make it UNSTABLE.
 stability[ref] = EdgeSrcType::UNSTABLE;
 break;
 } // else continue
 }
 }
 }
}

// ---------------------------------------------------------------------------
// ------[ OUTPUT FUNCTIONS ]-------------------------------------------------
// ---------------------------------------------------------------------------
void output_size_summary( string &dgroups_filename,
 SizeSum_t &size_summary )
{
 ofstream dgroups_file(dgroups_filename);
 dgroups_file << "\"num_objects\",\"size_bytes\",\"num_groups\"" << endl;
 for ( auto it = size_summary.begin();
 it != size_summary.end();
 ++it ) {
 unsigned int gsize = it->first;
 Summary *s = it->second;
 dgroups_file << s->num_objects << ","
 << s->size << ","
 << s->num_groups << endl;
 }
 dgroups_file.close();
}

void output_type_summary( string &dgroups_by_type_filename,
 TypeTotalSum_t &type_total_summary )
{
 ofstream dgroups_by_type_file(dgroups_by_type_filename);
 for ( TypeTotalSum_t::iterator it = type_total_summary.begin();
 it != type_total_summary.end();
 ++it ) {
 string myType = it->first;
 Summary *s = it->second;
 dgroups_by_type_file << myType << "," 
 << s->size << ","
 << s->num_groups << ","
 << s->num_objects << endl;
 }
 dgroups_by_type_file.close();
}

// All sorts of hacky debug function. Very brittle.
void debug_type_algo( Object *object,
 string& dgroup_kind )
{
 KeyType ktype = object->getKeyType();
 unsigned int objId = object->getId();
 if (ktype == KeyType::UNKNOWN_KEYTYPE) {
 cout << "ERROR: objId[ " << objId << " ] : "
 << "Keytype not set but algo determines [ " << dgroup_kind << " ]" << endl;
 return;
 }
 if (dgroup_kind == "CYCLE") {
 if (ktype != KeyType::CYCLE) {
 goto fail;
 }
 } else if (dgroup_kind == "CYCKEY") {
 if (ktype != KeyType::CYCLEKEY) {
 goto fail;
 }
 } else if (dgroup_kind == "DAG") {
 if (ktype != KeyType::DAG) {
 goto fail;
 }
 } else if (dgroup_kind == "DAGKEY") {
 if (ktype != KeyType::DAGKEY) {
 goto fail;
 }
 } else {
 cout << "ERROR: objId[ " << objId << " ] : "
 << "Unknown key type: " << dgroup_kind << endl;
 }
 return;
fail:
 cout << "ERROR: objId[ " << objId << " ] : "
 << "Keytype [ " << keytype2str(ktype) << " ]"
 << " doesn't match [ " << dgroup_kind << " ]" << endl;
 return;
}


void output_all_objects2( string &objectinfo_filename,
 HeapState &myheap,
 std::set<ObjectId_t> dag_keys,
 std::set<ObjectId_t> dag_all_set,
 std::set<ObjectId_t> all_keys,
 unsigned int final_time )
{
 ofstream object_info_file(objectinfo_filename);
 object_info_file << "---------------[ OBJECT INFO ]--------------------------------------------------" << endl;
 const vector<string> header( { "objId", "createTime", "deathTime", "size", "type",
 "diedBy", "lastUpdate", "subCause", "clumpKind",
 "deathContext1", "deathContext2", "firstNonJavaLibMethod",
 "deatchContext_height", "allocContext2", "allocContextType",
 "createTime_alloc", "deathTime_alloc",
 "allocSiteName", "stability", "last_actual_timestamp" } );

 for ( ObjectMap::iterator it = myheap.begin();
 it != myheap.end();
 ++it ) {
 Object *object = it->second;
 ObjectId_t objId = object->getId();
 KeyType ktype = object->getKeyType();
 string dgroup_kind;
 if (ktype == KeyType::CYCLE) {
 dgroup_kind = "CYC";
 } else if (ktype == KeyType::CYCLEKEY) {
 dgroup_kind = "CYCKEY";
 } else if (ktype == KeyType::DAG) {
 dgroup_kind = "DAG";
 } else if (ktype == KeyType::DAGKEY) {
 dgroup_kind = "DAGKEY";
 } else {
 dgroup_kind = "CYC";
 }
 string dtype;
 if (object->getDiedByStackFlag()) {
 dtype = "S"; // by stack
 } else if (object->getDiedByHeapFlag()) {
 if (object->wasLastUpdateFromStatic()) {
 dtype = "G"; // by static global
 } else {
 dtype = "H"; // by heap
 }
 } else {
 dtype = "E"; // program end
 }
 // TODO: Commented out the CONTEXT PAIR functionality that I'm not using.
 // TODO // Get the context pair and type for the allocation event
 // TODO ContextPair allocCpair = object->getAllocContextPair();
 // TODO Method *alloc_meth_ptr1 = std::get<0>(allocCpair);
 // TODO Method *alloc_meth_ptr2 = std::get<1>(allocCpair);
 // TODO string alloc_method1 = (alloc_meth_ptr1 ? alloc_meth_ptr1->getName() : "NONAME");
 // TODO string alloc_method2 = (alloc_meth_ptr2 ? alloc_meth_ptr2->getName() : "NONAME");
 // TODO // Get the context pair and type for the death event
 // TODO ContextPair deathCpair = object->getDeathContextPair();
 // TODO Method *death_meth_ptr1 = std::get<0>(deathCpair);
 // TODO Method *death_meth_ptr2 = std::get<1>(deathCpair);
 // TODO string death_method1 = (death_meth_ptr1 ? death_meth_ptr1->getName() : "NONAME");
 // TODO string death_method2 = (death_meth_ptr2 ? death_meth_ptr2->getName() : "NONAME");
 // END TODO: CONTEXT PAIR funcionality
 
 string death_method_l1 = object->getDeathContextSiteName(1);
 string death_method_l2 = object->getDeathContextSiteName(2);
 string death_method_nonjavalib = object->get_nonJavaLib_death_context();
 string allocsite_name = object->getAllocSiteName();
 ObjectRefType objstability = object->getRefTargetType();
 // S -> Stable
 // U -> Unstable
 // X -> Unknown
 string stability = ( (objstability == ObjectRefType::SINGLY_OWNED) ? "S"
 : (objstability == ObjectRefType::MULTI_OWNED ? "M" : "X") );
 unsigned int dtime = object->getDeathTime();
 object_info_file << objId
 << "," << object->getCreateTime()
 << "," << (dtime > 0 ? dtime : final_time)
 << "," << object->getSize()
 << "," << object->getType()
 << "," << dtype
 << "," << (object->wasLastUpdateNull() ? "NULL" : "VAL")
 << "," << (object->getDiedByStackFlag() ? (object->wasPointedAtByHeap() ? "SHEAP" : "SONLY")
 : "H")
 << "," << dgroup_kind
 //--------------------------------------------------------------------------------
 << "," << death_method_l1 // Fisrt level context for death
 //--------------------------------------------------------------------------------
 << "," << death_method_l2 // Second level context for death
 //--------------------------------------------------------------------------------
 << "," << death_method_nonjavalib // first nonJavaLib method
 //--------------------------------------------------------------------------------
 << "," << "TODO" // Full death context height
 // TODO << "," << alloc_method1 // Part 1 of simple context pair - alloc site
 //--------------------------------------------------------------------------------
 << "," << "X" // padding - used to be alloc_method2
 // TODO << "," << alloc_method2 // part 2 of simple context pair - alloc site
 //--------------------------------------------------------------------------------
 << "," << "X" // padding - used to be allocContextType
 // TODO << "," << (object->getAllocContextType() == CPairType::CP_Call ? "C" : "R") // C is call. R is return.
 //--------------------------------------------------------------------------------
 << "," << object->getCreateTimeAlloc()
 << "," << object->getDeathTimeAlloc()
 << "," << allocsite_name
 << "," << stability // S, U, or X
 << "," << object->getActualLastTimestamp()
 << endl;
 // TODO: The following can be made into a lookup table:
 // method names
 // allocsite names
 // type names
 // May only be necessary for performance reasons (ie, simulator eats up too much RAM 
 // on the larger benchmarks/programs.)
 }
 object_info_file << "---------------[ OBJECT INFO END ]----------------------------------------------" << endl;
 object_info_file.close();
}

void output_cycles( KeySet_t &keyset,
 string &cycle_filename,
 std::set<int> &node_set )
{
 ofstream cycle_file(cycle_filename);
 cycle_file << "---------------[ CYCLES ]-------------------------------------------------------" << endl;
 for ( KeySet_t::iterator it = keyset.begin();
 it != keyset.end();
 ++it ) {
 Object *obj = it->first;
 set< Object * > *sptr = it->second;
 unsigned int keyObjId = obj->getId();
 cycle_file << keyObjId;
 for ( set<Object *>::iterator tmp = sptr->begin();
 tmp != sptr->end();
 ++tmp ) {
 unsigned int tmpId = (*tmp)->getId();
 if (tmpId != keyObjId) {
 cycle_file << "," << tmpId;
 }
 node_set.insert((*tmp)->getId());
 }
 cycle_file << endl;
 }
 cycle_file << "---------------[ CYCLES END ]---------------------------------------------------" << endl;
 cycle_file.close();
}

unsigned int output_edges( HeapState &myheap,
 ofstream &edge_info_file )
{
 unsigned int total_done;
 // Iterate through 
 for ( auto it = myheap.begin_edgestate_map();
 it != myheap.end_edgestate_map();
 ++it ) {
 std::pair< Edge *, VTime_t > key = it->first;
 EdgeState estate = it->second;
 Edge *edge = std::get<0>(key);
 VTime_t ctime = std::get<1>(key);
 assert(edge);
 Object *src = edge->getSource();
 assert(src);
 VTime_t endtime = src->getDeathTime();
 if ( (estate == EdgeState::DEAD_BY_OBJECT_DEATH) ||
 (estate == EdgeState::DEAD_BY_UPDATE) ||
 (estate == EdgeState::DEAD_BY_PROGRAM_END) ) {
 // If the estate is any of these 3, then we've already
 // saved this edge. Log a WARNING.
 cerr << "WARNING: edge(" << edge->getSource()->getId() << ", "
 << edge->getTarget()->getId() << ")[time: "
 << edge->getCreateTime() << "] -> Estate["
 << static_cast<int>(estate) << "]" << endl;
 } else {
 if (estate == EdgeState::DEAD_BY_OBJECT_DEATH_NOT_SAVED) {
 estate = EdgeState::DEAD_BY_OBJECT_DEATH;
 } else if (estate == EdgeState::DEAD_BY_PROGRAM_END_NOT_SAVED) {
 estate = EdgeState::DEAD_BY_PROGRAM_END;
 } else if ((estate == EdgeState::NONE) or
 (estate == EdgeState::LIVE)) {
 cerr << "ERROR: edge(" << edge->getSource()->getId() << ", "
 << edge->getTarget()->getId() << ")[time: "
 << edge->getCreateTime() << "] -> Estate["
 << static_cast<int>(estate) << "]" << endl;
 cerr << "Quitting." << endl;
 exit(100);
 } 
 output_edge( edge,
 endtime,
 estate,
 edge_info_file );
 total_done++;
 }
 }
 return total_done;
}

#if 0
// Commented out code.
unsigned int output_edges_OLD( HeapState &myheap,
 string &edgeinfo_filename )
{
 unsigned int total_edges = 0;
 ofstream edge_info_file(edgeinfo_filename);
 edge_info_file << "---------------[ EDGE INFO ]----------------------------------------------------" << endl;
 // srcId, tgtId, allocTime, deathTime
 for ( EdgeSet::iterator it = myheap.begin_edges();
 it != myheap.end_edges();
 ++it ) {
 Edge *eptr = *it;
 Object *source = eptr->getSource();
 Object *target = eptr->getTarget();
 assert(source);
 assert(target);
 unsigned int srcId = source->getId();
 unsigned int tgtId = target->getId();
 EdgeState estate = eptr->getEdgeState();
 unsigned int endtime = ( (estate == EdgeState::DEAD_BY_OBJECT_DEATH) ?
 source->getDeathTime() : eptr->getEndTime() );
 // TODO: This code was meant to filter out edges not belonging to cycles.
 // But since we're also interested in the non-cycle nodes now, this is
 // probably dead code and won't be used again. TODO
 // set<int>::iterator srcit = node_set.find(srcId);
 // set<int>::iterator tgtit = node_set.find(tgtId);
 // if ( (srcit != node_set.end()) || (srcit != node_set.end()) ) {
 // TODO: Header?
 edge_info_file << srcId << ","
 << tgtId << ","
 << eptr->getCreateTime() << ","
 << endtime << ","
 << eptr->getSourceField() << ","
 << static_cast<int>(estate) << endl;
 // }
 total_edges++;
 }
 edge_info_file << "---------------[ EDGE INFO END ]------------------------------------------------" << endl;
 edge_info_file.close();
 return total_edges;
}
#endif // if 0 

// ----------------------------------------------------------------------
// Output the map of death context site -> count of obects dying
void output_context_summary( string &context_death_count_filename,
 ExecState &exstate )
{
 ofstream context_death_count_file(context_death_count_filename);
 for ( auto it = exstate.begin_deathCountMap();
 it != exstate.end_deathCountMap();
 ++it ) {
 ContextPair cpair = it->first;
 unsigned int total = it->second;
 Method *first = std::get<0>(cpair); 
 Method *second = std::get<1>(cpair); 
 string meth1_name = (first ? first->getName() : "NONAME");
 string meth2_name = (second ? second->getName() : "NONAME");
 context_death_count_file << meth1_name << "," 
 << meth2_name << "," 
 << total << endl;
 }
 context_death_count_file.close();
}

// ----------------------------------------------------------------------
// Output the map of simple context pair -> count of obects dying
// OLD CODE: Currently unused as we're not doing context pairs anymore
// TODO: void XXX_output_context_summary( string &context_death_count_filename,
// TODO: ExecState &exstate )
// TODO: {
// TODO: ofstream context_death_count_file(context_death_count_filename);
// TODO: for ( auto it = exstate.begin_deathCountMap();
// TODO: it != exstate.end_deathCountMap();
// TODO: ++it ) {
// TODO: ContextPair cpair = it->first;
// TODO: Method *first = std::get<0>(cpair); 
// TODO: Method *second = std::get<1>(cpair); 
// TODO: unsigned int total = it->second;
// TODO: unsigned int meth1_id = (first ? first->getId() : 0);
// TODO: unsigned int meth2_id = (second ? second->getId() : 0);
// TODO: string meth1_name = (first ? first->getName() : "NONAME");
// TODO: string meth2_name = (second ? second->getName() : "NONAME");
// TODO: char cptype = exstate.get_cptype_name(cpair);
// TODO: context_death_count_file << meth1_name << "," 
// TODO: << meth2_name << ","
// TODO: << cptype << ","
// TODO: << total << endl;
// TODO: }
// TODO: context_death_count_file.close();
// TODO: }

void output_reference_summary( string &reference_summary_filename,
 string &ref_reverse_summary_filename,
 string &stability_summary_filename,
 EdgeSummary_t &my_refsum,
 Object2EdgeSrcMap_t &my_obj2ref,
 EdgeSrc2Type_t &stability )
{
 ofstream edge_summary_file(reference_summary_filename);
 ofstream reverse_summary_file(ref_reverse_summary_filename);
 ofstream stability_summary_file(stability_summary_filename);
 //
 // Summarizes the objects pointed at by the reference (object Id + field Id)
 // This is the REF-SUMMARY output file. In garbology, the ReferenceReader
 // is responsible for reading it.
 for ( auto it = my_refsum.begin();
 it != my_refsum.end();
 ++it ) {
 // Key is an edge source (which we used to call 'ref')
 EdgeSrc_t ref = it->first;
 Object *obj = std::get<0>(ref); 
 FieldId_t fieldId = std::get<1>(ref); 
 // Value is a vector of Object pointers
 std::vector< Object * > objlist = it->second;
 ObjectId_t objId = (obj ? obj->getId() : 0);
 edge_summary_file << objId << "," // 1 - object Id
 << fieldId << ","; // 2 - field Id
 unsigned int actual_size = 0;
 for ( auto vecit = objlist.begin();
 vecit != objlist.end();
 ++vecit ) {
 if (*vecit) {
 ++actual_size;
 }
 }
 edge_summary_file << actual_size; // 3 - number of objects pointed at
 if (actual_size > 0) {
 for ( auto vecit = objlist.begin();
 vecit != objlist.end();
 ++vecit ) {
 if (*vecit) {
 edge_summary_file << "," << (*vecit)->getId(); // 4+ - objects pointed at
 }
 }
 }
 edge_summary_file << endl;
 }
 //
 // Summarizes the reverse, which is for each object (using its Id), give
 // the references that point to it.
 // This is the REF-REVERSE-SUMMARY output file. In garbology, the ReverseRefReader
 // is responsible for reading it.
 for ( auto it = my_obj2ref.begin();
 it != my_obj2ref.end();
 ++it ) {
 Object *obj = it->first;
 std::vector< EdgeSrc_t > reflist = it->second;
 if (!obj) {
 continue;
 }
 // obj is not NULL.
 ObjectId_t objId = obj->getId();
 reverse_summary_file << objId << "," // 1 - object Id
 << reflist.size(); // 2 - number of references in lifetime
 for ( auto vecit = reflist.begin();
 vecit != reflist.end();
 ++vecit ) {
 Object *srcObj = std::get<0>(*vecit); 
 FieldId_t fieldId = std::get<1>(*vecit); 
 ObjectId_t srcId = (srcObj ? srcObj->getId() : 0);
 reverse_summary_file << ",(" << srcId << "," << fieldId << ")"; // 3+ - list of incoming references
 }
 reverse_summary_file << endl;
 }
 //
 // Summarize the stability attributes of features.
 // output file is *-STABILITY-SUMMARY.csv
 for ( auto it = stability.begin();
 it != stability.end();
 ++it ) {
 EdgeSrc_t ref = it->first;
 EdgeSrcType reftype = it->second;
 Object *obj = std::get<0>(ref); 
 FieldId_t fieldId = std::get<1>(ref); 
 ObjectId_t objId = (obj ? obj->getId() : 0);
 stability_summary_file << objId << "," // 1 - object Id
 << fieldId << "," // 2 - field Id
 << edgesrctype2shortstr(reftype) // 3 - reference stability type
 << endl;
 }
 // Close the files.
 edge_summary_file.close();
 reverse_summary_file.close();
 stability_summary_file.close();
}


// ----------------------------------------------------------------------

int main(int argc, char* argv[])
{
 if (argc != 7) {
 cout << "Usage: " << argv[0] << " <namesfile> <output base name> <CYCLE/NOCYCLE> <OBJDEBUG/NOOBJDEBUG> <main.class> <main.function>" << endl;
 cout << " git version: " << build_git_sha << endl;
 cout << " build date : " << build_git_time << endl;
 cout << " CC kind : " << Exec.get_kind() << endl;
 exit(1);
 }
 cout << "# git version: " << build_git_sha << endl;
 cout << "# build date : " << build_git_time << endl;
 cout << "---------------[ START ]-----------------------------------------------------------" << endl;
 string basename(argv[2]);
 string cycle_filename( basename + "-CYCLES.csv" );
 // string edge_filename( basename + "-EDGES.txt" );
 string objectinfo_filename( basename + "-OBJECTINFO.txt" );
 string edgeinfo_filename( basename + "-EDGEINFO.txt" );
 string typeinfo_filename( basename + "-TYPEINFO.txt" );
 string summary_filename( basename + "-SUMMARY.csv" );
 string dsite_filename( basename + "-DSITES.csv" );

 string dgroups_filename( basename + "-DGROUPS.csv" );
 string dgroups_by_type_filename( basename + "-DGROUPS-BY-TYPE.csv" );
 string context_death_count_filename( basename + "-CONTEXT-DCOUNT.csv" );
 string reference_summary_filename( basename + "-REF-SUMMARY.csv" );
 string ref_reverse_summary_filename( basename + "-REF-REVERSE-SUMMARY.csv" );
 string stability_summary_filename( basename + "-STABILITY-SUMMARY.csv" );

 string call_context_filename( basename + "-CALL-CONTEXT.csv" );
 ofstream call_context_file(call_context_filename);
 Exec.set_output( &call_context_file );
 string nodemap_filename( basename + "-NODEMAP.csv" );
 ofstream nodemap_file(nodemap_filename);
 Exec.set_nodefile( &nodemap_file );

 string main_class(argv[5]);
 string main_function(argv[6]);
 cout << "Main class: " << main_class << endl;
 cout << "Main function: " << main_function << endl;

 string cycle_switch(argv[3]);
 bool cycle_flag = ((cycle_switch == "NOCYCLE") ? false : true);
 
 string obj_debug_switch(argv[4]);
 bool obj_debug_flag = ((obj_debug_switch == "OBJDEBUG") ? true : false);
 if (obj_debug_flag) {
 cout << "Enable OBJECT DEBUG." << endl;
 Heap.enableObjectDebug(); // default is no debug
 }

 cout << "Read names file..." << endl;
 ClassInfo::read_names_file( argv[1],
 main_class,
 main_function );

 cout << "Start trace..." << endl;
 // TODO: The path to the NVME is hardcoded for now.
 // We could make it an argument. s/could/probably should/
 // - RLV
 string basedir("/data/rveroy/NVME/tmp");
 MemoryPool<Object, 1342177280> objpool( basedir );
 MemoryPool<Edge, 1342177280> edgepool( basedir );
 FILE *f = fdopen(0, "r");
 ofstream edge_info_file(edgeinfo_filename);
 edge_info_file << "---------------[ EDGE INFO ]----------------------------------------------------" << endl;
 unsigned int total_objects = read_trace_file( f,
 edge_info_file,
 objpool,
 edgepool );
 unsigned int final_time = Exec.NowUp() + 1;
 unsigned int final_time_alloc = Heap.getAllocTime();
 cout << "Done at update time: " << Exec.NowUp() << endl;
 cout << "Total objects: " << total_objects << endl;
 cout << "Heap.size: " << Heap.size() << endl;
 // assert( total_objects == Heap.size() );
 Heap.end_of_program( final_time, edge_info_file );

 if (cycle_flag) {
 std::deque< pair<int,int> > edgelist; // TODO Do we need the edgelist?
 // per_group_summary: type -> vector of group summary
 GroupSum_t per_group_summary;
 // type_total_summary: summarize the stats per type
 TypeTotalSum_t type_total_summary;
 // size_summary: per group size summary. That is, for each group of size X,
 // add up the sizes.
 SizeSum_t size_summary;
 // Remember the key objects for non-cyclic death groups.
 set<ObjectId_t> dag_keys;
 deque<ObjectId_t> dag_all;
 // Reference stability summary
 EdgeSrc2Type_t stability_summary;
 // Lambdas for utility
 auto lfn = [](Object *ptr) -> unsigned int { return ((ptr) ? ptr->getId() : 0); };
 auto ifNull = [](Object *ptr) -> bool { return (ptr == NULL); };

 for ( KeySet_t::iterator kiter = keyset.begin();
 kiter != keyset.end();
 kiter++ ) {
 Object *optr = kiter->first;
 ObjectId_t objId = (optr ? optr->getId() : 0); 
 dag_keys.insert(objId);
 dag_all.push_back(objId);
 set< Object * > *sptr = kiter->second;
 if (!sptr) {
 continue; // TODO
 }
 deque< Object * > deqtmp;
 // std::copy( sptr->begin(), sptr->end(), deqtmp.begin() );
 // std::remove_if( deqtmp.begin(), deqtmp.end(), ifNull );
 for ( set< Object * >::iterator setit = sptr->begin();
 setit != sptr->end();
 setit++ ) {
 if (*setit) {
 deqtmp.push_back( *setit );
 }
 }
 if (deqtmp.size() > 0) {
 // TODO Not sure why this transform isn't working like the for loop.
 // Not too important, but kind of curious as to how I'm not using
 // std::transform properly.
 // TODO
 // std::transform( deqtmp.cbegin(),
 // deqtmp.cend(),
 // dag_all.begin(),
 // lfn );
 for ( deque< Object * >::iterator dqit = deqtmp.begin();
 dqit != deqtmp.end();
 dqit++ ) {
 if (*dqit) {
 dag_all.push_back( (*dqit)->getId() );
 }
 }
 }
 }
 // Copy all dag_all object Ids into dag_all_set to get rid of duplicates.
 set<ObjectId_t> dag_all_set( dag_all.cbegin(), dag_all.cend() );

 // scan_queue2 determines all the death groups that are cyclic
 // The '2' is a historical version of the function that won't be
 // removed.
 Heap.scan_queue2( edgelist,
 not_candidate_map );
 update_summary_from_keyset( keyset,
 per_group_summary,
 type_total_summary,
 size_summary );
 // Save key object IDs for _all_ death groups.
 set<ObjectId_t> all_keys;
 for ( KeySet_t::iterator kiter = keyset.begin();
 kiter != keyset.end();
 kiter++ ) {
 Object *optr = kiter->first;
 ObjectId_t objId = (optr ? optr->getId() : 0); 
 all_keys.insert(objId);
 // NOTE: We don't really need to add ALL objects here since
 // we can simply test against dag_all_set to see if it's a DAG
 // object. If not in dag_all_set, then it's a CYC object.
 }

 // Analyze the edge summaries
 summarize_reference_stability( stability_summary,
 edge_summary,
 obj2ref_map );
 // ----------------------------------------------------------------------
 // OUTPUT THE SUMMARIES
 // By size summary of death groups
 output_size_summary( dgroups_filename,
 size_summary );
 // Type total summary output
 output_type_summary( dgroups_by_type_filename,
 type_total_summary );
 // Output all objects info
 output_all_objects2( objectinfo_filename,
 Heap,
 dag_keys,
 dag_all_set,
 all_keys,
 final_time );
 output_context_summary( context_death_count_filename,
 Exec );
 output_reference_summary( reference_summary_filename,
 ref_reverse_summary_filename,
 stability_summary_filename,
 edge_summary,
 obj2ref_map,
 stability_summary );
 // TODO: What next? 
 // Output cycles
 // set<int> node_set;
 // output_cycles( keyset,
 // cycle_filename,
 // node_set );
 // TODO: Moved the edge output to as needed instead of all at the end.
 // TODO // Output all edges
 unsigned int added_edges = output_edges( Heap,
 edge_info_file );
 edge_info_file << "---------------[ EDGE INFO END ]------------------------------------------------" << endl;
 edge_info_file.close();
 } else {
 cout << "NOCYCLE chosen. Skipping cycle detection." << endl;
 }

 ofstream summary_file(summary_filename);
 summary_file << "---------------[ SUMMARY INFO ]----------------------------------------------------" << endl;
 summary_file << "number_of_objects," << Heap.size() << endl
 << "number_of_edges," << Heap.numberEdges() << endl
 << "died_by_stack," << Heap.getTotalDiedByStack2() << endl
 << "died_by_heap," << Heap.getTotalDiedByHeap2() << endl
 << "died_by_global," << Heap.getTotalDiedByGlobal() << endl
 << "died_at_end," << Heap.getTotalDiedAtEnd() << endl
 << "last_update_null," << Heap.getTotalLastUpdateNull() << endl
 << "last_update_null_heap," << Heap.getTotalLastUpdateNullHeap() << endl
 << "last_update_null_stack," << Heap.getTotalLastUpdateNullStack() << endl
 << "last_update_null_size," << Heap.getSizeLastUpdateNull() << endl
 << "last_update_null_heap_size," << Heap.getSizeLastUpdateNullHeap() << endl
 << "last_update_null_stack_size," << Heap.getSizeLastUpdateNullStack() << endl
 << "died_by_stack_only," << Heap.getDiedByStackOnly() << endl
 << "died_by_stack_after_heap," << Heap.getDiedByStackAfterHeap() << endl
 << "died_by_stack_only_size," << Heap.getSizeDiedByStackOnly() << endl
 << "died_by_stack_after_heap_size," << Heap.getSizeDiedByStackAfterHeap() << endl
 << "no_death_sites," << Heap.getNumberNoDeathSites() << endl
 << "size_died_by_stack," << Heap.getSizeDiedByStack() << endl
 << "size_died_by_heap," << Heap.getSizeDiedByHeap() << endl
 << "size_died_at_end," << Heap.getSizeDiedAtEnd() << endl
 << "vm_RC_zero," << Heap.getVMObjectsRefCountZero() << endl
 << "vm_RC_positive," << Heap.getVMObjectsRefCountPositive() << endl
 << "max_live_size," << Heap.maxLiveSize() << endl
 << "main_func_uptime," << Exec.get_main_func_uptime() << endl
 << "main_func_alloctime," << Exec.get_main_func_alloctime() << endl
 << "final_time," << final_time << endl
 << "final_time_alloc," << final_time_alloc << endl;
 summary_file << "---------------[ SUMMARY INFO END ]------------------------------------------------" << endl;
 summary_file.close();
 //---------------------------------------------------------------------
 ofstream dsite_file(dsite_filename);
 dsite_file << "---------------[ DEATH SITES INFO ]------------------------------------------------" << endl;
 for ( DeathSitesMap::iterator it = Heap.begin_dsites();
 it != Heap.end_dsites();
 ++it ) {
 Method *meth = it->first;
 set<string> *types = it->second;
 if (meth && types) {
 dsite_file << meth->getName() << "," << types->size();
 for ( set<string>::iterator sit = types->begin();
 sit != types->end();
 ++sit ) {
 dsite_file << "," << *sit;
 }
 dsite_file << endl;
 }
 }
 dsite_file << "---------------[ DEATH SITES INFO END ]--------------------------------------------" << endl;
 dsite_file.close();
 dsite_file << "---------------[ DONE ]------------------------------------------------------------" << endl;
 cout << "---------------[ DONE ]------------------------------------------------------------" << endl;
 cout << "# git version: " << build_git_sha << endl;
 cout << "# build date : " << build_git_time << endl;
}