notSoSimpleDag

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
#include <list>
#include <string>
#include "tbb/task_scheduler_init.h"
#include "tbb/tick_count.h"
#include "tbb/task.h"

using namespace tbb;
using namespace std;

#define WORKLOAD 100000000

void do_work() {
    for( int i=0; i<WORKLOAD; i++ ){
        ;
    }
}

class Dummy: public tbb::task {
    list<Dummy*> succ;
    string message;
public:
    Dummy(string msg) {
        message = msg;
    }
    void addSuccessor(Dummy* suc) {
        succ.push_back(suc);
    }
    tbb::task* execute( ) {
        __TBB_ASSERT(ref_count() == 0, "DUVAJ GA");
        cout << message << " Hello from execute()!\n";
        do_work();
        for (Dummy* dummy : succ)
        {
            dummy->decrement_ref_count();
            if (dummy->ref_count() == 0) {
                spawn(*dummy);
            }
        }


        return NULL;
    }
};

void serial() {
    //ToDo: Replace with actual tasks
    Dummy *t1 = new( tbb::task::allocate_root( ) ) Dummy("task A");
    t1->execute();
    t1->destroy(*t1);
    Dummy *t2 = new( tbb::task::allocate_root( ) ) Dummy("task B");
    t2->execute();
    t2->destroy(*t2);
    Dummy *t3 = new( tbb::task::allocate_root( ) ) Dummy("task C");
    t3->execute();
    t3->destroy(*t3);
    Dummy *t4 = new(tbb::task::allocate_root()) Dummy("task D");
    t4->execute();
    t4->destroy(*t4);
    Dummy *t5 = new(tbb::task::allocate_root()) Dummy("task F");
    t5->execute();
    t5->destroy(*t5);
    return;
}

void BuildAndEvaluateDAG() {
    Dummy* parent = new(task::allocate_root()) Dummy("TASK E");
    parent->set_ref_count(3);
    Dummy* f = new(task::allocate_root()) Dummy("TASK F");
    Dummy* d = new(task::allocate_root()) Dummy("TASK D");
    Dummy* c = new(task::allocate_root()) Dummy("TASK C");
    Dummy* b = new(task::allocate_root()) Dummy("TASK B");
    Dummy* a = new(task::allocate_root()) Dummy("TASK A");
    f->set_ref_count(0);
    d->set_ref_count(0);
    c->set_ref_count(0);

    b->set_ref_count(2);
    a->set_ref_count(2);
    a->addSuccessor(parent);
    b->addSuccessor(parent);
    f->addSuccessor(b);
    d->addSuccessor(a);
    c->addSuccessor(a);
    c->addSuccessor(b);
    parent->spawn(*d);
    parent->spawn(*c);
    parent->spawn_and_wait_for_all(*f);

    parent->execute();
    parent->destroy(*parent);

    return;
}

void parallel() {
    BuildAndEvaluateDAG();
    return;
}

int main( int argc, char* argv[] ) {

    tick_count startTime = tick_count::now();
    serial();
    tick_count stopTime = tick_count::now();
    cout << "serial finished. Took: " <<
        (stopTime - startTime).seconds()*1000 << "ms." << endl;

    startTime = tick_count::now();
    parallel();
    stopTime = tick_count::now();
    cout << "parallel finished. Took: " <<
        (stopTime - startTime).seconds()*1000 << "ms." << endl;

    return 0;
}