C++: Break out the phase-fair RW locks code

Part of refactoring sharedres.cpp.

4 files changed, 278 insertions, 243 deletions

diff --git a/native/Makefile b/native/Makefile
index 7ce7c47..e79c40e 100644
--- a/native/Makefile
+++ b/native/Makefile
@@ -57,6 +57,7 @@ CORE_OBJ  = tasks.o
 SYNC_OBJ  = sharedres.o dpcp.o mpcp.o
 SYNC_OBJ += fmlp_plus.o  global-fmlp.o
 SYNC_OBJ += global-omlp.o part-omlp.o clust-omlp.o
+SYNC_OBJ += rw-phase-fair.o
 
 # #### Targets ####
 
diff --git a/native/include/blocking.h b/native/include/blocking.h
index f5a5a13..0734d9d 100644
--- a/native/include/blocking.h
+++ b/native/include/blocking.h
@@ -41,6 +41,13 @@ Interference bound_blocking(const ContentionSet& cont,
                             const TaskInfo* exclude_tsk,
                             unsigned int min_priority = 0);
 
+Interference bound_blocking(const ContentionSet& cont,
+                            unsigned long interval,
+                            unsigned int max_total_requests,
+                            unsigned int max_requests_per_source,
+                            bool exclude_whole_cluster,
+                            const TaskInfo* exclude_tsk);
+
 Interference np_fifo_per_resource(
         const TaskInfo& tsk, const ClusterResources& clusters,
         unsigned int procs_per_cluster,
@@ -68,6 +75,44 @@ ClusterLimits np_fifo_limits(
         const unsigned int issued,
         int dedicated_irq);
 
+Interference bound_blocking_all_clusters(
+        const ClusterResources& clusters,
+        const ClusterLimits& limits,
+        unsigned int res_id,
+        unsigned long interval,
+        const TaskInfo* exclude_tsk);
+
+void split_by_type(const ContentionSet& requests,
+                   ContentionSet& reads,
+                   ContentionSet& writes);
+void split_by_type(const Resources& resources,
+                   Resources &reads,
+                   Resources &writes);
+void split_by_type(const ClusterResources& per_cluster,
+                   ClusterResources &reads);
+void split_by_type(const ClusterResources& per_cluster,
+                   ClusterResources &reads,
+                   ClusterResources &writes);
+
+struct RWCount {
+        unsigned int res_id;
+        unsigned int num_reads;
+        unsigned int num_writes;
+        unsigned int rlength;
+        unsigned int wlength;
+
+        RWCount(unsigned int id) : res_id(id),
+                                   num_reads(0),
+                                   num_writes(0),
+                                   rlength(0),
+                                   wlength(0)
+        {}
+};
+
+typedef std::vector<RWCount> RWCounts;
+
+void merge_rw_requests(const TaskInfo &tsk, RWCounts &counts);
+
 extern const unsigned int UNLIMITED;
 
 #endif
diff --git a/native/src/blocking/rw-phase-fair.cpp b/native/src/blocking/rw-phase-fair.cpp
new file mode 100644
index 0000000..65b85b4
--- /dev/null
+++ b/native/src/blocking/rw-phase-fair.cpp
@@ -0,0 +1,223 @@
+#include "sharedres.h"
+#include "blocking.h"
+
+#include "stl-helper.h"
+
+
+static Interference pf_writer_fifo(
+        const TaskInfo& tsk, const ClusterResources& writes,
+        const unsigned int num_writes,
+        const unsigned int num_reads,
+        const unsigned int res_id,
+        const unsigned int procs_per_cluster,
+        const int dedicated_irq)
+{
+        const unsigned int per_src_wlimit = num_reads + num_writes;
+        const unsigned long interval = tsk.get_response();
+        ClusterLimits limits;
+        int idx;
+
+        limits.reserve(writes.size());
+        enumerate(writes, ct, idx)
+        {
+                unsigned int total, parallelism = procs_per_cluster;
+
+                if (idx == dedicated_irq)
+                        parallelism--;
+
+                if (parallelism && (int) tsk.get_cluster() == idx)
+                        parallelism--;
+
+                // At most one blocking request per remote CPU in
+                // cluster per request.
+                if (parallelism)
+                        total = num_reads + num_writes * parallelism;
+                else
+                        // No interference from writers if we are hogging
+                        // the only available CPU.
+                        total = 0;
+
+                limits.push_back(ClusterLimit(total, per_src_wlimit));
+        }
+
+        Interference blocking;
+        blocking = bound_blocking_all_clusters(writes,
+                                               limits,
+                                               res_id,
+                                               interval,
+                                               &tsk);
+        return blocking;
+
+}
+
+static Interference pf_reader_all(
+        const TaskInfo& tsk,
+        const Resources& all_reads,
+        const unsigned int num_writes,
+        const unsigned int num_wblock,
+        const unsigned int num_reads,
+        const unsigned int res_id,
+        const unsigned int procs_per_cluster,
+        const unsigned int num_procs)
+{
+        const unsigned long interval = tsk.get_response();
+        Interference blocking;
+        unsigned int rlimit = std::min(num_wblock + num_writes,
+                                   num_reads + num_writes * (num_procs - 1));
+        blocking = bound_blocking(all_reads[res_id],
+                                  interval,
+                                  rlimit,
+                                  rlimit,
+                                  // exclude all if c == 1
+                                  procs_per_cluster == 1,
+                                  &tsk);
+        return blocking;
+}
+
+BlockingBounds* clustered_rw_omlp_bounds(const ResourceSharingInfo& info,
+                                         unsigned int procs_per_cluster,
+                                         int dedicated_irq)
+{
+        // split everything by partition
+        Clusters clusters;
+
+        split_by_cluster(info, clusters);
+
+        // split each partition by resource
+        ClusterResources resources;
+
+        split_by_resource(clusters, resources);
+
+        // split all by resource
+        Resources all_task_reqs, all_reads, __all_writes;
+        split_by_resource(info, all_task_reqs);
+        split_by_type(all_task_reqs, all_reads, __all_writes);
+
+        // sort each contention set by request length
+        sort_by_request_length(resources);
+        sort_by_request_length(all_reads);
+
+        // split by type --- sorted order is maintained
+        ClusterResources __reads, writes;
+        split_by_type(resources, __reads, writes);
+
+
+        // We need for each task the maximum request span.  We also need the
+        // maximum direct blocking from remote partitions for each request. We
+        // can determine both in one pass.
+
+        const unsigned int num_procs = procs_per_cluster * clusters.size();
+        unsigned int i;
+
+        // direct blocking results
+        BlockingBounds* _results = new BlockingBounds(info);
+        BlockingBounds& results = *_results;
+
+        for (i = 0; i < info.get_tasks().size(); i++)
+        {
+                const TaskInfo& tsk  = info.get_tasks()[i];
+                RWCounts rwcounts;
+                Interference bterm;
+
+                merge_rw_requests(tsk, rwcounts);
+
+                foreach(rwcounts, jt)
+                {
+                        const RWCount& rw = *jt;
+
+                        // skip placeholders
+                        if (!rw.num_reads && !rw.num_writes)
+                                continue;
+
+                        Interference wblocking,  rblocking;