Changes in libcfa/src/device/cpu.cfa [cf85f96:1f05c83]

File:

• libcfa/src/device/cpu.cfa (modified) (6 diffs)

libcfa/src/device/cpu.cfa

@@ -253 +253 @@
         }
 
+        #if defined(__CFA_WITH_VERIFY__)
+                // Check widths are consistent
+                for(i; 1~cpus) {
+                        for(j; cache_levels) {
+                                verifyf(raw[0][j].width == raw[i][j].width, "Unexpected width %u for cpu %u, index %u. Expected %u.", raw[i][j].width, i, j, raw[0][j].width);
+                        }
+                }
+        #endif
+
         return raw;
 }
 
-struct llc_map_t {
-        raw_cache_instance * raw;
-        unsigned count;
-        unsigned start;
-};
-
 // returns an allocate list of all the different distinct last level caches
-static [*llc_map_t, size_t cnt] distinct_llcs(unsigned cpus, unsigned llc_idx, raw_cache_instance ** raw) {
+static [*idx_range_t, size_t cnt] distinct_llcs(unsigned cpus, unsigned llc_idx, raw_cache_instance ** raw) {
         // Allocate at least one element
-        llc_map_t* ranges = alloc();
+        idx_range_t * ranges = alloc();
         size_t range_cnt = 1;
 
         // Initialize with element 0
-        ranges->raw = &raw[0][llc_idx];
-        ranges->count = 0;
-        ranges->start = -1u;
+        *ranges = raw[0][llc_idx].range;
 
         // Go over all other cpus
         CPU_LOOP: for(i; 1~cpus) {
                 // Check if the range is already there
-                raw_cache_instance * candidate = &raw[i][llc_idx];
+                idx_range_t candidate = raw[i][llc_idx].range;
                 for(j; range_cnt) {
-                        llc_map_t & exist = ranges[j];
+                        idx_range_t exist = ranges[j];
                         // If the range is already there just jump to the next cpu
-                        if(0 == strcmp(candidate->range, exist.raw->range)) continue CPU_LOOP;
+                        if(0 == strcmp(candidate, exist)) continue CPU_LOOP;
                 }
 
                 // The range wasn't there, added to the list
                 ranges = alloc(range_cnt + 1, ranges`realloc);
-                ranges[range_cnt].raw = candidate;
-                ranges[range_cnt].count = 0;
-                ranges[range_cnt].start = -1u;
+                ranges[range_cnt] = candidate;
                 range_cnt++;
         }
@@ -297 +296 @@
 struct cpu_pairing_t {
         unsigned cpu;
-        unsigned id;
+        unsigned llc_id;
 };
 
 int ?<?( cpu_pairing_t lhs, cpu_pairing_t rhs ) {
-        return lhs.id < rhs.id;
-}
-
-static [[]cpu_pairing_t] get_cpu_pairings(unsigned cpus, raw_cache_instance ** raw, llc_map_t * maps, size_t map_cnt) {
+        return lhs.llc_id < rhs.llc_id;
+}
+
+static [[]cpu_pairing_t] get_cpu_pairings(unsigned cpus, raw_cache_instance ** raw, idx_range_t * maps, size_t map_cnt) {
         cpu_pairing_t * pairings = alloc(cpus);
 
@@ -311 +310 @@
                 idx_range_t want = raw[i][0].range;
                 MAP_LOOP: for(j; map_cnt) {
-                        if(0 != strcmp(want, maps[j].raw->range)) continue MAP_LOOP;
-
-                        pairings[i].id = j;
+                        if(0 != strcmp(want, maps[j])) continue MAP_LOOP;
+
+                        pairings[i].llc_id = j;
                         continue CPU_LOOP;
                 }
@@ -322 +321 @@
         return pairings;
 }
-
-#include <fstream.hfa>
 
 extern "C" {
@@ -348 +345 @@
 
                 // Find number of distinct cache instances
-                llc_map_t * maps;
+                idx_range_t * maps;
                 size_t map_cnt;
                 [maps, map_cnt] =  distinct_llcs(cpus, cache_levels - llc, raw);
 
-                #if defined(__CFA_WITH_VERIFY__)
-                // Verify that the caches cover the all the cpus
-                {
-                        unsigned width1 = 0;
-                        unsigned width2 = 0;
-                        for(i; map_cnt) {
-                                const char * _;
-                                width1 += read_width(maps[i].raw->range, strlen(maps[i].raw->range), &_);
-                                width2 += maps[i].raw->width;
-                        }
-                        verify(width1 == cpus);
-                        verify(width2 == cpus);
-                }
-                #endif
+                /* paranoid */ verify((map_cnt * raw[0][cache_levels - llc].width) == cpus);
 
                 // Get mappings from cpu to cache instance
@@ -373 +357 @@
                 qsort(pairings, cpus);
 
-                {
-                        unsigned it = 0;
-                        for(i; cpus) {
-                                unsigned llc_id = pairings[i].id;
-                                if(maps[llc_id].start == -1u) {
-                                        maps[llc_id].start = it;
-                                        it += maps[llc_id].raw->width;
-                                        /* paranoid */ verify(maps[llc_id].start < it);
-                                        /* paranoid */ verify(it != -1u);
-                                }
-                        }
-                        /* paranoid */ verify(it == cpus);
-                }
-
-                // From the mappings build the actual cpu map we want
+                unsigned llc_width = raw[0][cache_levels - llc].width;
+
+                // From the mappins build the actual cpu map we want
                 struct cpu_map_entry_t * entries = alloc(cpus);
                 for(i; cpus) { entries[i].count = 0; }
                 for(i; cpus) {
-                        /* paranoid */ verify(pairings[i].id < map_cnt);
                         unsigned c = pairings[i].cpu;
-                        unsigned llc_id = pairings[i].id;
-                        unsigned width = maps[llc_id].raw->width;
-                        unsigned start = maps[llc_id].start;
-                        unsigned self  = start + (maps[llc_id].count++);
-                        entries[c].count = width;
-                        entries[c].start = start;
-                        entries[c].self  = self;
+                        entries[c].start = pairings[i].llc_id * llc_width;
+                        entries[c].count = llc_width;
                 }