source: CIVL/examples/compare/provesa/ADFirstAidKit/profile/reader.cc

#include "reader.h"
#include "string-utils.h"
#include <cstdio>
#include <stdexcept>
#include <map>

// Real impl
using namespace std;
struct TapenadeLogReaderImpl {
        FILE *file;
        int file_length;
        map<int,string> function_id_2_name;
        ~TapenadeLogReaderImpl() {
                if (file)
                        fclose(file);
        }
};
template <typename T> static T read(TapenadeLogReaderImpl *impl) {
  T data;
  fread(&data, 1, sizeof(T), impl->file);
  return data;
}
template <> static inline string read(TapenadeLogReaderImpl *impl) {
  unsigned int len = read<unsigned int>(impl);
  char *buffer = new char[len];
  fread(buffer, 1, len, impl->file);
  string ret(buffer, len);
  delete[] buffer;
  return ret;
}
template <> static inline TapenadeLogEvent read(TapenadeLogReaderImpl *impl) {
        unsigned int function_id = read<unsigned int>(impl);
        string &function_name = impl->function_id_2_name[function_id];
        unsigned int kind, size;
        unsigned long long int time;
        kind = read<unsigned int>(impl);
        time = read<unsigned long long int>(impl);
        size = read<unsigned int>(impl);
        return TapenadeLogEvent(function_name, kind, time, size);
}
static inline bool eof(TapenadeLogReaderImpl *impl) {
        int curPos = ftell(impl->file);
        return (curPos >= impl->file_length);
}

static void initialize(TapenadeLogReaderImpl *&impl, const string &filename, bool &ok, bool &init) throw(runtime_error) {
        if ((! init) && ok) {
                impl = new TapenadeLogReaderImpl();
                impl->file = fopen(filename.c_str(), "r");
                if (! impl->file) {
                  ok = false;
                  throw new runtime_error("Can't open "+
                                           filename+
                                          "for reading");
                }
                fseek(impl->file, 0, SEEK_END);
                impl->file_length = ftell(impl->file);
                rewind(impl->file);
                // Read functions ids
                unsigned int hashtable_count;
                hashtable_count = read<unsigned int>(impl);
                while (hashtable_count--) {
                        unsigned int function_id = read<unsigned int>(impl);
                        impl->function_id_2_name[function_id] =
                          read<string>(impl);
                }
                init = true;
        }
}

// Interface
#define TapenadeLogReaderTemplate(type, name) \
type TapenadeLogReader::name() throw(runtime_error) {\
        if (! initialized)\
                initialize(impl, filename, ok, initialized);\
        if (ok)\
                return read<type>(impl);\
        else \
                throw runtime_error("End of file reached in \""+\
                                    filename+"\"");\
}
bool TapenadeLogReader::eof() throw(runtime_error) {
        if (! initialized)
                initialize(impl, filename, ok, initialized);
        if (ok)
                return ::eof(impl);
        else 
                throw runtime_error("End of file reached in \""+
                                    filename+"\"");
}
TapenadeLogReader::~TapenadeLogReader() {
        if (impl) {
                delete impl;
        }
}

TapenadeLogReaderTemplate(TapenadeLogEvent, readEvent);

// Interface for ReadingOnlyInAdjointBranch
ReadingOnlyInAdjointBranch::ReadingOnlyInAdjointBranch(const std::string &filename)
{
        unread = false;
        done =false;
        adjoint_branch = false;
        reader = new TapenadeLogReader(filename);
}
ReadingOnlyInAdjointBranch::~ReadingOnlyInAdjointBranch() {
        if (unreadEvent)
                delete unreadEvent;
        if (reader)
                delete reader;
}

bool ReadingOnlyInAdjointBranch::eof() throw(runtime_error)
{
        if (adjoint_branch)
                return reader->eof();
        if (done)
                return true;

        while (! reader->eof()) {
                TapenadeLogEvent event(reader->readEvent());
                string suffix = last_part_after(event.function_name, '_');
                if (suffix == "b" || suffix == "fwd") {
                        adjoint_branch_first_function_name = event.function_name;
                        adjoint_branch_first_function_recursion = 1;
                        unreadEvent = new TapenadeLogEvent(event);
                        unread = true;
                        adjoint_branch = true;
                        return false;
                }
        }
        return true;
}
TapenadeLogEvent ReadingOnlyInAdjointBranch::readEvent() throw(runtime_error)
{
        if (! adjoint_branch)
                throw runtime_error("readEvent called without verifying eof!");
        if (unread) {
                TapenadeLogEvent event(*unreadEvent);
                delete unreadEvent;
                unreadEvent = 0;
                unread = false;
                return event;
        }
        TapenadeLogEvent event(reader->readEvent());
        if (event.function_name == adjoint_branch_first_function_name) {
                if (event.kind == END)
                        if (adjoint_branch_first_function_recursion == 1) {
                                adjoint_branch = false;
                                done = true;
                        } else
                                adjoint_branch_first_function_recursion--;
                if (event.kind == BEGIN)
                        adjoint_branch_first_function_recursion++;
        }
        return event;
}