Add st_show2 bin

1 files changed, 391 insertions, 0 deletions

diff --git a/src/showst2.cpp b/src/showst2.cpp
new file mode 100644
index 0000000..e43a589
--- /dev/null
+++ b/src/showst2.cpp
@@ -0,0 +1,391 @@
+#include <iostream>
+#include <sstream>
+#include <fstream>
+#include <set>
+#include <vector>
+#include <map>
+
+#include <blitz/array.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+extern "C"
+{
+#include "load.h"
+#include "sched_trace.h"
+#include "eheap.h"
+}
+
+using namespace std;
+using namespace blitz;
+
+double SCALE = 1000000.0; // ms
+//double SCALE =   1000.0; // us
+
+static void usage(const char *str)
+{
+        fprintf(stderr,
+                "\n  USAGE\n"
+                "\n"
+                "    st_show [opts] <file.st>+\n"
+                "\n"
+                "  OPTIONS\n"
+                "     -r         -- find task system release and exit\n"
+                "     -f         -- use first non-zero event as system release\n"
+                "                   if no system release event is found\n"
+                "     -c         -- display a count of the number of events\n"
+                "\n\n"
+                );
+        fprintf(stderr, "Aborted: %s\n", str);
+        exit(1);
+}
+
+struct Job
+{
+        u32 jid;
+
+        mutable u32 actual_exe;
+        mutable u32 estimated_exe;
+        mutable s32 accum_err;
+
+        mutable u64 release;
+        mutable u64 deadline;
+        mutable u64 completion;
+
+        bool operator<(const Job& rhs) const
+        {
+                return(jid < rhs.jid);
+        }
+};
+
+struct Task
+{
+        u16 pid;
+
+        mutable u32 wcet;
+        mutable u32 period;
+        mutable u8 level;
+        mutable u8 partition;
+
+
+        bool operator<(const Task& rhs) const
+        {
+          return (pid < rhs.pid);
+        }
+};
+
+map<Task, set<Job> > traceData;
+
+template <class T>
+double stddev(const T& arr)
+{
+    double stddev;
+
+    if(arr.size() > 1)
+    {
+        double avg = blitz::mean(arr);
+
+        blitz::Array<double, 1> devs(arr.size());
+        devs = arr - avg;
+        devs *= devs;
+        double devsum = blitz::sum(devs);
+        stddev = sqrt(devsum/(devs.size()-1));
+    }
+    else
+    {
+        stddev = 0.0;
+    }
+
+    return(stddev);
+}
+
+#define OPTSTR "rcf"
+
+int main(int argc, char** argv)
+{
+        unsigned int count;
+        struct heap *h;
+        struct heap_node *hn, *first = NULL;
+        u64 time;
+        struct st_event_record *rec;
+        int show_count = 0;
+        int opt;
+
+        while ((opt = getopt(argc, argv, OPTSTR)) != -1) {
+                switch (opt) {
+                case 'c':
+                        show_count = 1;
+                        break;
+                case ':':
+                        usage("Argument missing.");
+                        break;
+                case '?':
+                default:
+                        usage("Bad argument.");
+                        break;
+                }
+        }
+
+        u64 starttime = 0;
+
+        h = load(argv + optind, argc - optind, &count);
+        if (!h)
+                return 1;
+        if (show_count)
+                printf("Loaded %u events.\n", count);
+        while ((hn = heap_take(earlier_event, h))) {
+
+                rec = (st_event_record*)heap_node_value(hn);
+
+                time =  event_time(rec);
+                if (time != 0 && !first)
+                        first = hn;
+                time /= 1000000; /* convert to milliseconds */
+
+                if(rec->hdr.type == ST_SYS_RELEASE && starttime == 0)
+                {
+                        starttime = rec->data.sys_release.when;
+                }
+                else if(rec->hdr.type == ST_PARAM)
+                {
+                        Task tsk;
+                        tsk.pid = rec->hdr.pid;
+                        tsk.level = 'A' + rec->data.param.level;
+                        tsk.partition = '0' + rec->data.param.partition;
+                        tsk.wcet = rec->data.param.wcet;
+                        tsk.period = rec->data.param.period;
+
+                        map<Task, set<Job> >::iterator iter = traceData.find(tsk);
+                        if(iter == traceData.end())
+                        {
+                                traceData[tsk] = set<Job>();
+                        }
+                        else
+                        {
+                                iter->first.wcet = rec->data.param.wcet;
+                                iter->first.period = rec->data.param.period;
+                        }
+                }
+                else if(rec->hdr.type == ST_RELEASE)
+                {
+                        Task srch;
+                        srch.pid = rec->hdr.pid;
+
+                        map<Task, set<Job> >::iterator iter = traceData.find(srch);
+
+                        // force the task to be there.
+                        if(iter == traceData.end())
+                        {
+                                traceData[srch] = set<Job>();
+                                iter = traceData.find(srch);
+                                iter->first.period = rec->data.release.release - rec->data.release.deadline;
+                        }
+
+                        if(iter != traceData.end())
+                        {
+                                Job jsrch;
+                                jsrch.jid = rec->hdr.job;
+
+                                set<Job>::iterator jter = iter->second.find(jsrch);
+                                if(jter == iter->second.end())
+                                {
+                                        jsrch.release = rec->data.release.release;
+                                        jsrch.deadline = rec->data.release.deadline;
+                                        jsrch.completion = 0;
+                                        jsrch.actual_exe = 0;
+                                        jsrch.estimated_exe = 0;
+                                        jsrch.accum_err = 0;
+                                        iter->second.insert(jsrch);
+                                }
+                                else
+                                {
+                                        jter->release = rec->data.release.release;
+                                        jter->deadline = rec->data.release.deadline;
+                                }
+                        }
+                        else
+                        {
+                                cerr<<"Could not match release to task."<<endl;
+                        }
+                }
+                else if(rec->hdr.type == ST_COMPLETION)
+                {
+                        Task srch;
+                        srch.pid = rec->hdr.pid;
+
+            map<Task, set<Job> >::iterator iter = traceData.find(srch);
+
+                        // force the task to be there.
+                        if(iter == traceData.end())
+                        {   
+                                traceData[srch] = set<Job>();
+                                iter = traceData.find(srch);
+                                iter->first.period = 0;
+                        }   
+
+                        if(iter != traceData.end())
+                        {
+                                Job jsrch;
+                                jsrch.jid = rec->hdr.job;
+                                set<Job>::iterator j = iter->second.find(jsrch);
+
+
+                                if(j == iter->second.end())
+                                {
+                                        jsrch.release = 0;
+                                        jsrch.deadline = 0;
+                                        jsrch.actual_exe = 0;
+                                        jsrch.estimated_exe = 0;
+                                        jsrch.accum_err = 0;
+                                        iter->second.insert(jsrch);
+                                        j = iter->second.find(jsrch);
+                                }
+
+                                if(j != iter->second.end())
+                                {
+                                        j->completion = rec->data.completion.when;
+                                }
+                                else
+                                {
+                                        cerr<<"Could not find the job to complete."<<endl;
+                                }
+                        }
+                        else
+                        {
+                                cerr<<"Could not find the task for which has a job to complete."<<endl;
+                        }
+                }
+        }
+
+        // data loaded.  discard unfinished jobs. and first and last.
+        for(map<Task, set<Job> >::iterator tsk(traceData.begin()), tskEnd(traceData.end());
+                tsk != tskEnd;
+                ++tsk)
+        {
+                if(!tsk->second.empty())
+                {
+                        tsk->second.erase(tsk->second.begin());
+                }
+                if(!tsk->second.empty())
+                {
+                        set<Job>::iterator last(tsk->second.end());
+                        --last;
+                        tsk->second.erase(last);
+                }
+
+                for(set<Job>::iterator job(tsk->second.begin()), jobEnd(tsk->second.end());
+                        job != jobEnd;
+                        )
+                {
+                        if(job->completion == 0 || job->release == 0 || job->deadline == 0)
+                        {
+                                set<Job>::iterator temp(job);
+                                ++job;
+                                tsk->second.erase(temp);
+                        }
+                        else
+                        {
+                                ++job;
+                        }
+                }
+        }
+
+
+        ofstream outs;
+        outs.open("summary.csv");
+        outs<<"level, part, period, wcet, jobs, tard-avg, " <<
+                "tard-max, misses" << endl;
+
+        // print stats.
+        for(map<Task, set<Job> >::iterator tsk(traceData.begin()), tskEnd(traceData.end());
+                tsk != tskEnd;
+                ++tsk)
+        {
+                size_t sz = tsk->second.size();
+                Array<double, 1> releases(sz);
+                Array<double, 1> completions(sz);
+                Array<double, 1> deadlines(sz);
+
+                Array<double, 1> actual_exes(sz);
+                Array<double, 1> est_exes(sz);
+                Array<double, 1> accum_errs(sz);
+
+                int i = 0;
+                for(set<Job>::iterator job(tsk->second.begin()),
+                            jobEnd(tsk->second.end());
+                        job != jobEnd;
+                        ++job, ++i)
+                {
+                        releases(i) = (double)job->release;
+                        completions(i) = (double)job->completion;
+                        deadlines(i) = (double)job->deadline;
+
+                        actual_exes(i) = (double)job->actual_exe;
+                        est_exes(i) = (double)job->estimated_exe;
+                        accum_errs(i) = (double)job->accum_err;
+                }
+
+                Array<double, 1> rt(sz);
+                Array<double, 1> tardy(sz);
+                Array<double, 1> delta_exe(sz);
+                Array<double, 1> misses(sz);
+
+                rt = completions - releases;
+                tardy = where(completions > deadlines, completions - deadlines, 0.0);
+                delta_exe = actual_exes - est_exes;
+                misses = where(completions > deadlines, 1, 0);
+                misses = blitz::sum(misses);
+
+                // done computing data.  dump stuff to files.
+
+                // tardiness growth and estimates
+                stringstream filename;
+                double per = ((int)(roundf(tsk->first.period/10000.0)))/100.0;
+                double exe = ((int)(roundf(tsk->first.wcet/10000.0)))/100.0;
+                filename<<"e"<<exe<<"_p"<<per<<"_pid"<<tsk->first.pid;
+                if(stddev(actual_exes)/SCALE > 0.4)
+                {
+                        filename<<"+";
+                }
+                filename<<".csv";
+
+                ofstream tardGrowth;
+                tardGrowth.open(filename.str().c_str());
+                tardGrowth<<"#time, tardiness, actual_exe, est_exe, delta_exe, accum_err"<<endl;
+                for(i = 0; i < (int)sz; ++i)
+                {
+                        tardGrowth<<(completions(i)-starttime)/SCALE<<", "
+                                          <<tardy(i)/SCALE<<", "
+                                          <<actual_exes(i)/SCALE<<", "
+                                          <<est_exes(i)/SCALE<<", "
+                                          <<delta_exe(i)/SCALE<<", "
+                                          <<accum_errs(i)/SCALE<<endl;
+                }
+                tardGrowth.close();
+
+                // task stats
+                outs<<tsk->first.level<<", "
+                    <<tsk->first.partition << ", "
+                    <<tsk->first.period/SCALE<<", "  // id
+                    <<tsk->first.wcet/SCALE<<", "       // id
+                    <<sz<<", "
+                    <<blitz::max(tardy)/SCALE<<", "
+                    <<blitz::mean(tardy)/SCALE<<", "
+                    <<blitz::sum(misses)<<endl;
+        }
+        outs.close();
+
+        return 0;
+}
+
+
+
+
+
+
+
+
+
+