Changes in libcfa/src/device/cpu.cfa [33608cb:ab4a595]

File:

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

libcfa/src/device/cpu.cfa

@@ -30 +30 @@
         #include <fcntl.h>
 }
-
-#include "algorithms/range_iterator.hfa"
 
 // search a string for character 'character' but looking atmost at len
@@ -137 +135 @@
                 count++;
         }
-        int ret = iterate_dir(path, lambda);
-        if(ret == ENOTDIR) return 0;
+        iterate_dir(path, lambda);
 
         /* paranoid */ verifyf(count == max + 1, "Inconsistent %s count, counted %d, but max %s was %d", prefix, count, prefix, (int)max);
@@ -146 +143 @@
 
 // Count number of cpus in the system
-static [int, const char *] count_cpus(void) {
+static int count_cpus(void) {
         const char * fpath = "/sys/devices/system/cpu/online";
         int fd = open(fpath, 0, O_RDONLY);
@@ -162 +159 @@
 
         const char * _;
-        return [read_width(buff, r - 1, &_), strndup(buff, r - 1)];
+        int cnt = read_width(buff, r - 1, &_);
+        /* paranoid */ verify(cnt == count_prefix_dirs("/sys/devices/system/cpu", "cpu"));
+        return cnt;
 }
 
@@ -227 +226 @@
 
 struct raw_cache_instance {
-        idx_range_t range;      // A text description of the cpus covered
-        unsigned width;         // The number of cpus covered
-        unsigned char level;    // the cache level
+        idx_range_t range;
+        unsigned width;
+        unsigned char level;
         // FIXME add at least size and type
 };
@@ -236 +235 @@
 static void ^?{}(raw_cache_instance & this) { free(this.range);}
 
-// Returns a 2D array of instances of size [cpu count][cache levels]
-// where cache level doesn't include instruction caches
-raw_cache_instance ** build_raw_cache_table(unsigned cpus_c, idx_range_t cpus, unsigned idxs, unsigned cache_levels)
+raw_cache_instance ** build_raw_cache_table(unsigned cpus, unsigned idxs, unsigned cache_levels)
 {
-        raw_cache_instance ** raw = alloc(cpus_c, '\0'`fill);
-
-        RangeIter rc = { cpus };
-        while(moveNext(rc)) {
-                unsigned i = rc.com;
+        raw_cache_instance ** raw = alloc(cpus);
+        for(i; cpus) {
                 raw[i] = alloc(cache_levels);
                 void addcache(unsigned fidx, unsigned char level, idx_range_t range, size_t len) {
@@ -269 +263 @@
 
 // returns an allocate list of all the different distinct last level caches
-static [*llc_map_t, size_t cnt] distinct_llcs(idx_range_t cpus, unsigned llc_idx, raw_cache_instance ** raw) {
+static [*llc_map_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();
         size_t range_cnt = 1;
 
-        RangeIter rc = { cpus };
-        __attribute__((unused)) bool ret =
-        moveNext(rc);
-        /* paranoid */ verify( ret );
-        /* paranoid */ verify( rc.com >= 0 );
-
         // Initialize with element 0
-        ranges->raw = &raw[rc.com][llc_idx];
+        ranges->raw = &raw[0][llc_idx];
         ranges->count = 0;
         ranges->start = -1u;
 
         // Go over all other cpus
-        CPU_LOOP: while(moveNext(rc)) {
-                unsigned i = rc.com;
+        CPU_LOOP: for(i; 1~cpus) {
                 // Check if the range is already there
                 raw_cache_instance * candidate = &raw[i][llc_idx];
@@ -317 +304 @@
 }
 
-static [[]cpu_pairing_t] get_cpu_pairings(unsigned cpus_c, idx_range_t cpus, raw_cache_instance ** raw, llc_map_t * maps, size_t map_cnt) {
-        cpu_pairing_t * pairings = alloc(cpus_c);
-
-        RangeIter rc = { cpus };
-        CPU_LOOP: while(moveNext(rc)) {
-                unsigned i = rc.com;
+static [[]cpu_pairing_t] get_cpu_pairings(unsigned cpus, raw_cache_instance ** raw, llc_map_t * maps, size_t map_cnt) {
+        cpu_pairing_t * pairings = alloc(cpus);
+
+        CPU_LOOP: for(i; cpus) {
                 pairings[i].cpu = i;
                 idx_range_t want = raw[i][0].range;
@@ -342 +327 @@
 extern "C" {
         void __cfaabi_device_startup( void ) {
-                int cpus_c;
-                const char * cpus;
-                [cpus_c, cpus] = count_cpus();
-                #if defined(__CFA_WITH_VERIFY__)
-                // Verify that the mapping is self consistant.
-                {
-                        RangeIter rc = { cpus };
-                        while(moveNext(rc)) {
-                                unsigned i = rc.com;
-                                verify(cpus_c > i);
-                        }
-                }
-                #endif
-
+                int cpus = count_cpus();
                 int idxs = count_cache_indexes();
 
@@ -361 +333 @@
                 unsigned cache_levels = 0;
                 unsigned llc = 0;
-                if (idxs != 0) {
+                {
                         unsigned char prev = -1u;
                         void first(unsigned idx, unsigned char level, const char * map, size_t len) {
@@ -373 +345 @@
 
                 // Read in raw data
-                raw_cache_instance ** raw = build_raw_cache_table(cpus_c, cpus, idxs, cache_levels);
+                raw_cache_instance ** raw = build_raw_cache_table(cpus, idxs, cache_levels);
 
                 // Find number of distinct cache instances
@@ -390 +362 @@
                                 width2 += maps[i].raw->width;
                         }
-                        verify(width1 == cpus_c);
-                        verify(width2 == cpus_c);
+                        verify(width1 == cpus);
+                        verify(width2 == cpus);
                 }
                 #endif
 
                 // Get mappings from cpu to cache instance
-                cpu_pairing_t * pairings = get_cpu_pairings(cpus_c, cpus, raw, maps, map_cnt);
+                cpu_pairing_t * pairings = get_cpu_pairings(cpus, raw, maps, map_cnt);
 
                 // Sort by cache instance
-                qsort(pairings, cpus_c);
+                qsort(pairings, cpus);
 
                 {
                         unsigned it = 0;
-                        RangeIter rc = { cpus };
-                        while(moveNext(rc)) {
-                                unsigned i = rc.com;
+                        for(i; cpus) {
                                 unsigned llc_id = pairings[i].id;
                                 if(maps[llc_id].start == -1u) {
@@ -414 +384 @@
                                 }
                         }
-                        /* paranoid */ verify(it == cpus_c);
+                        /* paranoid */ verify(it == cpus);
                 }
 
                 // From the mappings build the actual cpu map we want
-                struct cpu_map_entry_t * entries = alloc(cpus_c);
-                for(i; cpus_c) { entries[i].count = 0; }
-
-                RangeIter rc = { cpus };
-                while(moveNext(rc)) {
-                        unsigned i = rc.com;
+                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;
@@ -439 +406 @@
                 free(pairings);
 
-                for(i; cpus_c) {
-                        if( raw[i] ) for(j; cache_levels) {
+                for(i; cpus) {
+                        for(j; cache_levels) {
                                 ^(raw[i][j]){};
                         }
@@ -448 +415 @@
 
                 cpu_info.llc_map = entries;
-                cpu_info.hthrd_count = cpus_c;
-                cpu_info.llc_count = map_cnt;
+                cpu_info.hthrd_count = cpus;
         }