feat: add log

.clang-format

@@ -0,0 +1,78 @@
+# Generated from CLion C/C++ Code Style settings
+BinPackParameters: false
+BasedOnStyle: LLVM
+AccessModifierOffset: -4
+AlignArrayOfStructures: Left
+AlignAfterOpenBracket: Align
+AlignConsecutiveAssignments:
+  Enabled: true
+  AcrossEmptyLines: true
+  AcrossComments: false
+
+AlignOperands: DontAlign
+AllowAllArgumentsOnNextLine: false
+AllowAllConstructorInitializersOnNextLine: false
+AllowAllParametersOfDeclarationOnNextLine: false
+AllowShortBlocksOnASingleLine: Always
+AllowShortCaseLabelsOnASingleLine: false
+AllowShortFunctionsOnASingleLine: All
+AllowShortIfStatementsOnASingleLine: true
+AllowShortLambdasOnASingleLine: All
+AllowShortLoopsOnASingleLine: true
+AlwaysBreakTemplateDeclarations: Yes
+# 函数和返回类型分两行，方便阅读
+AlwaysBreakAfterReturnType: TopLevelDefinitions
+BreakBeforeBraces: Custom
+BraceWrapping:
+  AfterCaseLabel: false
+  AfterClass: false
+  AfterControlStatement: Never
+  AfterEnum: false
+  AfterFunction: true
+  AfterNamespace: false
+  AfterUnion: false
+  BeforeCatch: false
+  BeforeElse: false
+  IndentBraces: false
+  SplitEmptyFunction: false
+  SplitEmptyRecord: true
+BreakBeforeBinaryOperators: NonAssignment
+BreakBeforeTernaryOperators: true
+BreakConstructorInitializers: BeforeColon
+ConstructorInitializerAllOnOneLineOrOnePerLine: true
+BreakInheritanceList: BeforeColon
+ColumnLimit: 120
+CompactNamespaces: false
+ContinuationIndentWidth: 4
+EmptyLineBeforeAccessModifier: LogicalBlock
+SeparateDefinitionBlocks: Always
+IndentCaseLabels: false
+IndentPPDirectives: None
+IndentWidth: 4
+KeepEmptyLinesAtTheStartOfBlocks: true
+MaxEmptyLinesToKeep: 1
+NamespaceIndentation: None
+ObjCSpaceAfterProperty: false
+ObjCSpaceBeforeProtocolList: false
+PointerAlignment: Right
+ReflowComments: false
+SortIncludes: CaseSensitive
+SpaceAfterCStyleCast: true
+SpaceAfterLogicalNot: false
+SpaceAfterTemplateKeyword: false
+SpaceBeforeAssignmentOperators: true
+SpaceBeforeCpp11BracedList: false
+SpaceBeforeCtorInitializerColon: true
+SpaceBeforeInheritanceColon: true
+SpaceBeforeParens: ControlStatements
+SpaceBeforeRangeBasedForLoopColon: true
+SpaceInEmptyParentheses: false
+SpacesBeforeTrailingComments: 0
+SpacesInAngles: false
+SpacesInCStyleCastParentheses: false
+SpacesInContainerLiterals: false
+SpacesInParentheses: false
+SpacesInSquareBrackets: false
+TabWidth: 4
+UseTab: Never
+PenaltyIndentedWhitespace: 1

drama/Makefile

@@ -4,7 +4,7 @@ LDIR=lib
 BUILD=obj
 ODIR=src/.obj
 
-CFLAGS=-I$(IDIR) #-ggdb
+CFLAGS=-I$(IDIR) -O3 #-ggdb
 # CXX=g++
 LDFLAGS=
 

drama/src/include/rev-mc.h

@@ -1,14 +1,12 @@
-#include "utils.h"
 #include "unistd.h"
-
+#include "utils.h"
 
 typedef struct {
-	char* 		v_addr; 
+    char *v_addr;
     uint64_t p_addr;
 } addr_tuple;
 
 //----------------------------------------------------------
 // 			Functions
 
-
+void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size, char *o_file, uint64_t flags);
-void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size, char* o_file, uint64_t flags);

drama/src/include/utils.h

@@ -3,15 +3,13 @@
 #include <stdint.h>
 #include <stdio.h>
 
-
+#define BIT(x) (1ULL << (x))
-#define BIT(x) (1ULL<<(x))
+#define KB(x) ((x) << 10ULL)
-#define KB(x) ((x)<<10ULL)
+#define MB(x) ((x) << 20ULL)
-#define MB(x) ((x)<<20ULL)
+#define GB(x) ((x) << 30ULL)
-#define GB(x) ((x)<<30ULL)
 #define CL_SHIFT 6
 #define CL_SIZE 64
 
-
 #define F_CLEAR 0L
 #define F_VERBOSE BIT(0)
 #define F_EXPORT BIT(1)
@@ -19,77 +17,66 @@
 #define MEM_SHIFT (30L)
 #define MEM_MASK 0b11111ULL << MEM_SHIFT
 #define F_ALLOC_HUGE BIT(MEM_SHIFT)
-#define F_ALLOC_HUGE_1G 	F_ALLOC_HUGE | BIT(MEM_SHIFT+1)
+#define F_ALLOC_HUGE_1G F_ALLOC_HUGE | BIT(MEM_SHIFT + 1)
-#define F_ALLOC_HUGE_2M		F_ALLOC_HUGE | BIT(MEM_SHIFT+2)
+#define F_ALLOC_HUGE_2M F_ALLOC_HUGE | BIT(MEM_SHIFT + 2)
-#define F_POPULATE			BIT(MEM_SHIFT+3)
+#define F_POPULATE BIT(MEM_SHIFT + 3)
-
-
 
 //----------------------------------------------------------
 // 			Static functions
 
-static inline __attribute__((always_inline)) void clflush(volatile void *p)
+static inline __attribute__((always_inline)) void
+clflush(volatile void *p)
 {
-	asm volatile("clflush (%0)\n"
+    asm volatile("clflush (%0)\n" ::"r"(p) : "memory");
-		:: "r" (p) : "memory");
 }
 
-
+static inline __attribute__((always_inline)) void
-static inline __attribute__((always_inline)) void mfence() 
+mfence()
 {
-	asm volatile ("mfence" : : : "memory");
+    asm volatile("mfence" : : : "memory");
 }
 
-
+static inline __attribute__((always_inline)) void
-static inline __attribute__((always_inline)) void lfence() 
+lfence()
 {
-	asm volatile ("lfence" : : : "memory");
+    asm volatile("lfence" : : : "memory");
 }
 
-
+static inline __attribute__((always_inline)) uint64_t
-static inline __attribute__((always_inline)) uint64_t rdtscp(void)
+rdtscp(void)
 {
     uint64_t lo, hi;
-	asm volatile("rdtscp\n"
+    asm volatile("rdtscp\n" : "=a"(lo), "=d"(hi)::"%rcx");
-		: "=a" (lo), "=d" (hi)
-		:: "%rcx");
     return (hi << 32) | lo;
 }
 
-
+static inline __attribute__((always_inline)) uint64_t
-static inline __attribute__((always_inline)) uint64_t rdtsc(void)
+rdtsc(void)
 {
     uint64_t lo, hi;
-	asm volatile("rdtsc\n"
+    asm volatile("rdtsc\n" : "=a"(lo), "=d"(hi)::"%rcx");
-		: "=a" (lo), "=d" (hi)
-		:: "%rcx");
     return (hi << 32) | lo;
 }
 
-
 //----------------------------------------------------------
 // 			Memory alloc
 
-
 typedef struct {
-	char* 		buffer;
+    char *buffer;
     uint64_t size;
     uint64_t flags;
 } mem_buff_t;
 
+int alloc_buffer(mem_buff_t *mem);
 
-int alloc_buffer(mem_buff_t* mem);
+int free_buffer(mem_buff_t *mem);
-
-int free_buffer(mem_buff_t* mem);
-
 
 //----------------------------------------------------------
 // 			Helpers
-int gt(const void * a, const void * b);
+int gt(const void *a, const void *b);
 
-double mean(uint64_t* vals, size_t size);
+double mean(uint64_t *vals, size_t size);
 
-uint64_t median(uint64_t* vals, size_t size);
+uint64_t median(uint64_t *vals, size_t size);
-
-char* bit_string(uint64_t val);
 
+char *bit_string(uint64_t val);

drama/src/main.c

@@ -1,72 +1,67 @@
 
 #include "stdio.h"
 // #include <x86intrin.h> /* for rdtsc, rdtscp, clflush */
-#include <stdint.h>
 #include <assert.h>
-#include <string.h>
-#include <stdlib.h>
-#include <time.h>
-#include <sched.h>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/stat.h>
 #include <fcntl.h>
-#include <stdbool.h>
 #include <getopt.h>
+#include <sched.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
 
-#include "utils.h"
 #include "rev-mc.h"
+#include "utils.h"
 
-
+#define SETS_std (2 * 16)// 1rk-1ch
-#define SETS_std        (2*16) // 1rk-1ch
 #define ROUNDS_std 1000
 #define THRESHOLD_std 340
 #define MEM_SIZE_std GB(5L)
 #define O_FILE_std "access.csv"
 
-
 #define FIELDS "base,probe,rounds,time"
 
-
 //-----------------------------------------------
 //                  GLOBALS
 
-
-
 //-----------------------------------------------
-void print_usage() {
+void
-    fprintf(stderr, "[ LOG ] - Usage ./test [-h] [-s sets] [-r rounds] [-t threshold] [-o o_file] [-v] [--mem mem_size]\n");
+print_usage()
+{
+    fprintf(stderr,
+            "[ LOG ] - Usage ./test [-h] [-s sets] [-r rounds] [-t threshold] [-o o_file] [-v] [--mem mem_size]\n");
     fprintf(stderr, "          -h                     = this help message\n");
     fprintf(stderr, "          -s sets                = number of expected sets            (default: %d)\n", SETS_std);
-    fprintf(stderr, "          -r rounds              = number of rounds per tuple         (default: %d)\n", ROUNDS_std);
+    fprintf(stderr, "          -r rounds              = number of rounds per tuple         (default: %d)\n",
-    fprintf(stderr, "          -t threshold           = time threshold for conflicts       (default: %d)\n", THRESHOLD_std);
+            ROUNDS_std);
-    fprintf(stderr, "          -o o_file              = output file for mem profiling      (default: %s)\n", O_FILE_std);
+    fprintf(stderr, "          -t threshold           = time threshold for conflicts       (default: %d)\n",
-    fprintf(stderr, "          --mem mem_size         = allocation size                    (default: %ld)\n", (uint64_t) MEM_SIZE_std);
+            THRESHOLD_std);
+    fprintf(stderr, "          -o o_file              = output file for mem profiling      (default: %s)\n",
+            O_FILE_std);
+    fprintf(stderr, "          --mem mem_size         = allocation size                    (default: %ld)\n",
+            (uint64_t) MEM_SIZE_std);
     fprintf(stderr, "          -v                     = verbose\n\n");
 }
 
-
-
-
-
-
-
-
-
-
 //-----------------------------------------------
-int main(int argc, char** argv) {
+int
+main(int argc, char **argv)
+{
 
     uint64_t flags   = 0ULL;
     size_t sets_cnt  = SETS_std;
     size_t rounds    = ROUNDS_std;
     size_t m_size    = MEM_SIZE_std;
     size_t threshold = THRESHOLD_std;
-    char*       o_file      = (char*) O_FILE_std;
+    char *o_file     = (char *) O_FILE_std;
 
     flags |= F_POPULATE;
 
-    if(geteuid() != 0) {
+    if (geteuid() != 0) {
         fprintf(stderr, "[ERROR] - You need to run as root to access pagemap!\n");
         exit(1);
     }
@@ -74,30 +69,27 @@ int main(int argc, char** argv) {
     while (1) {
         int this_option_optind              = optind ? optind : 1;
         int option_index                    = 0;
-        static struct option long_options[] =
+        static struct option long_options[] = {
-            {
             /* These options set a flag. */
             {"mem", required_argument, 0, 0},
             {0,     0,                 0, 0}
         };
-        int arg = getopt_long (argc, argv, "o:s:r:t:hv",
+        int arg = getopt_long(argc, argv, "o:s:r:t:hv", long_options, &option_index);
-                       long_options, &option_index);
 
-        if (arg == -1) 
+        if (arg == -1) break;
-            break;
 
-        switch(arg) {
+        switch (arg) {
         case 0:
-                switch (option_index){
+            switch (option_index) {
             case 0:
-                        m_size = atoi(optarg); // TODO proper parsing of this
+                m_size = atoi(optarg);// TODO proper parsing of this
                 break;
             default:
                 break;
             }
             break;
         case 'o':
-                o_file = (char*) malloc(sizeof(char)*strlen(optarg));
+            o_file = (char *) malloc(sizeof(char) * strlen(optarg));
             strncpy(o_file, optarg, strlen(optarg));
             flags |= F_EXPORT;
             break;
@@ -117,18 +109,11 @@ int main(int argc, char** argv) {
         default:
             print_usage();
             return 0;
-            
         }
     }
 
-
-
     rev_mc(sets_cnt, threshold, rounds, m_size, o_file, flags);
     return 0;
-
 }
 
-
-
-
 /*I'm refactoring the set struct to add also timing in there. */

drama/src/rev-mc.c

@@ -19,23 +19,20 @@
 
 #define BOOL_XOR(a, b) ((a) != (b))
 #define O_HEADER "base,probe,time\n"
-#define ALIGN_TO(X, Y)                                                         \
+#define ALIGN_TO(X, Y) ((X) & (~((1LL << (Y)) - 1LL)))// Mask out the lower Y bits
-  ((X) & (~((1LL << (Y)) - 1LL)))          // Mask out the lower Y bits
 #define LS_BITMASK(X) ((1LL << (X)) - 1LL)            // Mask only the lower X bits
 
-#define SET_SIZE 40 // elements per set
+#define SET_SIZE 40// elements per set
 #define VALID_THRESH 0.75f
 #define SET_THRESH 0.95f
-#define BITSET_SIZE 256 // bitset used to exploit bitwise operations
+#define BITSET_SIZE 256// bitset used to exploit bitwise operations
 #define ROW_SET_CNT 5
 
 // from
 // https://stackoverflow.com/questions/1644868/define-macro-for-debug-printing-in-c
 #define verbose_printerr(fmt, ...)                                                                                     \
     do {                                                                                                               \
-    if (flags & F_VERBOSE) {                                                   \
+        if (flags & F_VERBOSE) { fprintf(stderr, fmt, ##__VA_ARGS__); }                                                \
-      fprintf(stderr, fmt, ##__VA_ARGS__);                                     \
-    }                                                                          \
     } while (0)
 
 typedef std::vector<addr_tuple> set_t;
@@ -52,11 +49,13 @@ void verify_sets(std::vector<set_t> &sets, uint64_t threshold, size_t rounds);
 #pragma push_options
 #pragma optimize("O0")
 static std::vector<uint64_t> time_vals;
-uint64_t time_tuple(volatile char *a1, volatile char *a2, size_t rounds) {
+
+uint64_t
+time_tuple(volatile char *a1, volatile char *a2, size_t rounds)
+{
 
     // uint64_t* time_vals = (uint64_t*) calloc(rounds, sizeof(uint64_t));
-  if (rounds > time_vals.size())
+    if (rounds > time_vals.size()) time_vals.resize(rounds);
-    time_vals.resize(rounds);
 
     uint64_t t0;
     sched_yield();
@@ -75,19 +74,27 @@ uint64_t time_tuple(volatile char *a1, volatile char *a2, size_t rounds) {
     // free(time_vals);
     return mdn;
 }
+
 #pragma pop_options
 
 //----------------------------------------------------------
-char *get_rnd_addr(char *base, size_t m_size, size_t align) {
+char *
-  return (char *)ALIGN_TO((uint64_t)base, (uint64_t)align) +
+get_rnd_addr(char *base, size_t m_size, size_t align)
-         ALIGN_TO(rand() % m_size, (uint64_t)align);
+{
+    return (char *) ALIGN_TO((uint64_t) base, (uint64_t) align) + ALIGN_TO(rand() % m_size, (uint64_t) align);
 }
 
 //----------------------------------------------------------
-uint64_t get_pfn(uint64_t entry) { return ((entry) & 0x3fffffffffffff); }
+uint64_t
+get_pfn(uint64_t entry)
+{
+    return ((entry) & 0x3fffffffffffff);
+}
 
 //----------------------------------------------------------
-uint64_t get_phys_addr(uint64_t v_addr) {
+uint64_t
+get_phys_addr(uint64_t v_addr)
+{
     uint64_t entry;
     uint64_t offset = (v_addr / 4096) * sizeof(entry);
     uint64_t pfn;
@@ -103,15 +110,19 @@ uint64_t get_phys_addr(uint64_t v_addr) {
 }
 
 //----------------------------------------------------------
-addr_tuple gen_addr_tuple(char *v_addr) {
+addr_tuple
-  return (addr_tuple){v_addr, get_phys_addr((uint64_t)v_addr)};
+gen_addr_tuple(char *v_addr)
+{
+    return (addr_tuple){v_addr, get_phys_addr((uint64_t) v_addr)};
 }
 
 //----------------------------------------------------------
 // https://www.cs.umd.edu/~gasarch/TOPICS/factoring/fastgauss.pdf
 // gaussian elimination in GF2
 
-std::vector<uint64_t> reduce_masks(std::vector<uint64_t> masks) {
+std::vector<uint64_t>
+reduce_masks(std::vector<uint64_t> masks)
+{
 
     size_t height, width, height_t, width_t;
 
@@ -130,15 +141,11 @@ std::vector<uint64_t> reduce_masks(std::vector<uint64_t> masks) {
     std::vector<uint64_t> filtered_masks;
 
     for (size_t i = 0; i < height; i++) {
-    for (size_t j = 0; j < width; j++) {
+        for (size_t j = 0; j < width; j++) { mtx[i][width - j - 1] = (masks[i] & (1ULL << (j))); }
-      mtx[i][width - j - 1] = (masks[i] & (1ULL << (j)));
-    }
     }
 
     for (size_t i = 0; i < height; i++) {
-    for (size_t j = 0; j < width; j++) {
+        for (size_t j = 0; j < width; j++) { mtx_t[j][i] = mtx[i][j]; }
-      mtx_t[j][i] = mtx[i][j];
-    }
     }
 
     int64_t pvt_col = 0;
@@ -148,15 +155,11 @@ std::vector<uint64_t> reduce_masks(std::vector<uint64_t> masks) {
             if (mtx_t[row][pvt_col]) {
                 filtered_masks.push_back(masks[pvt_col]);
                 for (size_t c = 0; c < width_t; c++) {
-          if (c == pvt_col)
+                    if (c == pvt_col) continue;
-            continue;
+                    if (!(mtx_t[row][c])) continue;
-          if (!(mtx_t[row][c]))
-            continue;
 
                     // column sum
-          for (size_t r = 0; r < height_t; r++) {
+                    for (size_t r = 0; r < height_t; r++) { mtx_t[r][c] = BOOL_XOR(mtx_t[r][c], mtx_t[r][pvt_col]); }
-            mtx_t[r][c] = BOOL_XOR(mtx_t[r][c], mtx_t[r][pvt_col]);
-          }
                 }
                 break;
             }
@@ -169,23 +172,23 @@ std::vector<uint64_t> reduce_masks(std::vector<uint64_t> masks) {
 
 //----------------------------------------------------------
 // from https://graphics.stanford.edu/~seander/bithacks.html#NextBitPermutation
-uint64_t next_bit_permutation(uint64_t v) {
+uint64_t
+next_bit_permutation(uint64_t v)
+{
     uint64_t t = v | (v - 1);
     return (t + 1) | (((~t & -~t) - 1) >> (__builtin_ctzl(v) + 1));
 }
 
 //----------------------------------------------------------
-std::vector<uint64_t> find_functions(std::vector<set_t> sets,
+std::vector<uint64_t>
-                                     size_t max_fn_bits, size_t msb,
+find_functions(std::vector<set_t> sets, size_t max_fn_bits, size_t msb, uint64_t flags)
-                                     uint64_t flags) {
+{
 
     std::vector<uint64_t> masks;
     verbose_printerr("~~~~~~~~~~ Candidate functions ~~~~~~~~~~\n");
 
     for (size_t bits = 1L; bits <= max_fn_bits; bits++) {
-    uint64_t fn_mask =
+        uint64_t fn_mask   = ((1L << (bits)) - 1);// avoid the first 6 bits since they are the cacheline bits
-        ((1L << (bits)) -
-         1); // avoid the first 6 bits since they are the cacheline bits
         uint64_t last_mask = (fn_mask << (msb - bits));
         fn_mask <<= CL_SHIFT;
         verbose_printerr("[ LOG ] - #Bits: %ld \n", bits);
@@ -200,13 +203,10 @@ std::vector<uint64_t> find_functions(std::vector<set_t> sets,
                 for (size_t i = 1; i < curr_set.size(); i++) {
                     uint64_t res_base  = __builtin_parityl(curr_set[0].p_addr & fn_mask);
                     uint64_t res_probe = __builtin_parityl(curr_set[i].p_addr & fn_mask);
-          if (res_base != res_probe) {
+                    if (res_base != res_probe) { goto next_mask; }
-            goto next_mask;
                 }
             }
-      }
+            verbose_printerr("\t Candidate: 0x%0lx \t\t bits: %s\n", fn_mask, bit_string(fn_mask));
-      verbose_printerr("\t Candidate: 0x%0lx \t\t bits: %s\n", fn_mask,
-                       bit_string(fn_mask));
             masks.push_back(fn_mask);
 
         next_mask:
@@ -216,22 +216,18 @@ std::vector<uint64_t> find_functions(std::vector<set_t> sets,
     verbose_printerr("~~~~~~~~~~ Found Functions ~~~~~~~~~~\n");
     masks = reduce_masks(masks);
     if (flags & F_VERBOSE) {
-    for (auto m : masks) {
+        for (auto m : masks) { fprintf(stderr, "\t Valid Function: 0x%0lx \t\t bits: %s\n", m, bit_string(m)); }
-      fprintf(stderr, "\t Valid Function: 0x%0lx \t\t bits: %s\n", m,
-              bit_string(m));
-    }
-  }
-  for (auto m : masks) {
-    fprintf(stdout, "0x%lx\n", m);
     }
+    for (auto m : masks) { fprintf(stdout, "0x%lx\n", m); }
     return masks;
 }
 
-std::vector<int> find_set_bits(uint64_t val) {
+std::vector<int>
+find_set_bits(uint64_t val)
+{
     std::vector<int> set_bits;
     for (int i = 0; i < 64; i++) {
-    if (!(val & (1ULL << i)))
+        if (!(val & (1ULL << i))) continue;
-      continue;
 
         set_bits.push_back(i);
     }
@@ -239,12 +235,11 @@ std::vector<int> find_set_bits(uint64_t val) {
 }
 
 //----------------------------------------------------------
-std::vector<uint8_t> get_dram_fn(uint64_t addr,
+std::vector<uint8_t>
-                                 std::vector<uint64_t> fn_masks) {
+get_dram_fn(uint64_t addr, std::vector<uint64_t> fn_masks)
+{
     std::vector<uint8_t> addr_dram;
-  for (auto fn : fn_masks) {
+    for (auto fn : fn_masks) { addr_dram.push_back(__builtin_parityl(addr & fn)); }
-    addr_dram.push_back(__builtin_parityl(addr & fn));
-  }
     return addr_dram;
 }
 
@@ -254,8 +249,13 @@ It currently finds some of the interesting bits for the row addressing.
 @TODO 	still need to figure out which bits are used for the row addressing and
 which are from the bank selection. This is currently done manually
 */
-uint64_t find_row_mask(std::vector<set_t> &sets, std::vector<uint64_t> fn_masks,
+uint64_t
-                       mem_buff_t mem, uint64_t threshold, uint64_t flags) {
+find_row_mask(std::vector<set_t> &sets,
+              std::vector<uint64_t> fn_masks,
+              mem_buff_t mem,
+              uint64_t threshold,
+              uint64_t flags)
+{
 
     addr_tuple base_addr = gen_addr_tuple(get_rnd_addr(mem.buffer, mem.size, 0));
     std::vector<set_t> same_row_sets;
@@ -265,34 +265,28 @@ uint64_t find_row_mask(std::vector<set_t> &sets, std::vector<uint64_t> fn_masks,
     for (int i = 0; i < 2; i++) {
         verbose_printerr("[LOG] - Set #%d\n", i);
         addr_tuple base_addr           = sets[i][0];
-    std::vector<uint8_t> base_dram =
+        std::vector<uint8_t> base_dram = get_dram_fn((uint64_t) base_addr.p_addr, fn_masks);
-        get_dram_fn((uint64_t)base_addr.p_addr, fn_masks);
         same_row_sets.push_back({base_addr});
         uint64_t cnt = 0;
         while (cnt < ROW_SET_CNT) {
 
             addr_tuple tmp = gen_addr_tuple(get_rnd_addr(mem.buffer, mem.size, 0));
-      if (get_dram_fn((uint64_t)tmp.p_addr, fn_masks) != base_dram)
+            if (get_dram_fn((uint64_t) tmp.p_addr, fn_masks) != base_dram) continue;
-        continue;
 
-      uint64_t time = time_tuple((volatile char *)base_addr.v_addr,
+            uint64_t time = time_tuple((volatile char *) base_addr.v_addr, (volatile char *) tmp.v_addr, 1000);
-                                 (volatile char *)tmp.v_addr, 1000);
 
-      if (time > threshold)
+            if (time > threshold) continue;
-        continue;
 
-      verbose_printerr("[LOG] - %lx - %lx\t Time: %ld <== GOTCHA\n",
+            verbose_printerr("[LOG] - %lx - %lx\t Time: %ld <== GOTCHA\n", base_addr.p_addr, tmp.p_addr, time);
-                       base_addr.p_addr, tmp.p_addr, time);
 
             same_row_sets[i].push_back(tmp);
             cnt++;
         }
     }
 
-  uint64_t row_mask = LS_BITMASK(16); // use 16 bits for the row
+    uint64_t row_mask  = LS_BITMASK(16);// use 16 bits for the row
     uint64_t last_mask = (row_mask << (40 - 16));
-  row_mask <<=
+    row_mask <<= CL_SHIFT;// skip the lowest 6 bits since they're used for CL addressing
-      CL_SHIFT; // skip the lowest 6 bits since they're used for CL addressing
 
     while (row_mask < last_mask) {
         if (row_mask & LS_BITMASK(CL_SHIFT)) {
@@ -304,9 +298,7 @@ uint64_t find_row_mask(std::vector<set_t> &sets, std::vector<uint64_t> fn_masks,
             addr_tuple base_addr = addr_pool[0];
             for (int i = 1; i < addr_pool.size(); i++) {
                 addr_tuple tmp = addr_pool[i];
-        if ((tmp.p_addr & row_mask) != (base_addr.p_addr & row_mask)) {
+                if ((tmp.p_addr & row_mask) != (base_addr.p_addr & row_mask)) { goto next_mask; }
-          goto next_mask;
-        }
             }
         }
 
@@ -319,19 +311,17 @@ uint64_t find_row_mask(std::vector<set_t> &sets, std::vector<uint64_t> fn_masks,
     // super hackish way to recover the real row mask
     for (auto m : fn_masks) {
         uint64_t lsb = (1 << (__builtin_ctzl(m) + 1));
-    if (lsb & row_mask) {
+        if (lsb & row_mask) { row_mask ^= (1 << __builtin_ctzl(m)); }
-      row_mask ^= (1 << __builtin_ctzl(m));
     }
-  }
+    verbose_printerr("[LOG] - Row mask: 0x%0lx \t\t bits: %s\n", row_mask, bit_string(row_mask));
-  verbose_printerr("[LOG] - Row mask: 0x%0lx \t\t bits: %s\n", row_mask,
-                   bit_string(row_mask));
     printf("0x%lx\n", row_mask);
     return row_mask;
 }
 
 //----------------------------------------------------------
-void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
+void
-            char *o_file, uint64_t flags) {
+rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size, char *o_file, uint64_t flags)
+{
 
     time_t t;
 
@@ -342,7 +332,7 @@ void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
     std::set<char *> used_addr;
     std::vector<uint64_t> fn_masks;
 
-  srand((unsigned)time(&t));
+    srand((unsigned) time(&t));
 
     if (flags & F_EXPORT) {
         if (o_file == NULL) {
@@ -366,8 +356,7 @@ void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
 
     while (!found_enough(sets, sets_cnt, SET_SIZE)) {
         char *rnd_addr = get_rnd_addr(mem.buffer, mem.size, CL_SHIFT);
-    if (is_in(rnd_addr, used_addr))
+        if (is_in(rnd_addr, used_addr)) continue;
-      continue;
 
         // used_addr.push_back(rnd_addr);
         used_addr.insert(rnd_addr);
@@ -377,15 +366,11 @@ void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
         for (size_t idx = 0; idx < sets.size(); idx++) {
             uint64_t time  = 0;
             addr_tuple tmp = sets[idx][0];
-      time = time_tuple((volatile char *)tmp.v_addr, (volatile char *)tp.v_addr,
+            time           = time_tuple((volatile char *) tmp.v_addr, (volatile char *) tp.v_addr, rounds);
-                        rounds);
+            if (flags & F_EXPORT) { dprintf(o_fd, "%lx,%lx,%ld\n", (uint64_t) tp.v_addr, (uint64_t) tmp.v_addr, time); }
-      if (flags & F_EXPORT) {
-        dprintf(o_fd, "%lx,%lx,%ld\n", (uint64_t)tp.v_addr,
-                (uint64_t)tmp.v_addr, time);
-      }
             if (time > threshold) {
-        verbose_printerr("[LOG] - [%ld] Set: %03ld -\t %lx - %lx\t Time: %ld\n",
+                verbose_printerr("[LOG] - [%ld] Set: %03ld -\t %lx - %lx\t Time: %ld\n", used_addr.size(), idx,
-                         used_addr.size(), idx, tp.p_addr, tmp.p_addr, time);
+                                 tp.p_addr, tmp.p_addr, time);
                 sets[idx].push_back(tp);
                 found_set = true;
                 break;
@@ -402,17 +387,16 @@ void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
     filter_sets(sets, SET_SIZE);
 
 #ifdef DEBUG_SETS
-  fprintf(stderr,
+    fprintf(stderr, "[ LOG ] - Cleansing sets. This may take a while... stay put\n");
-          "[ LOG ] - Cleansing sets. This may take a while... stay put\n");
     verify_sets(sets, threshold, rounds);
     fprintf(stderr, "[ LOG ] - Done\n");
 #endif
 
-  if (flags & F_VERBOSE) {
+    if (flags & F_VERBOSE) { print_sets(sets); }
-    print_sets(sets);
-  }
 
+    fprintf(stderr, "Start Find Function\n");
     fn_masks = find_functions(sets, 6, 30, flags);
+    fprintf(stderr, "Start Find RowMask\n");
     uint64_t row_mask = find_row_mask(sets, fn_masks, mem, threshold, flags);
 
     free_buffer(&mem);
@@ -423,84 +407,85 @@ void rev_mc(size_t sets_cnt, size_t threshold, size_t rounds, size_t m_size,
 //----------------------------------------------------------
 //          Helpers
 
-bool is_in(char *val, std::set<char *> arr) {
+bool
+is_in(char *val, std::set<char *> arr)
+{
     return arr.find(val) != arr.end();
 }
 
-bool is_in(char *val, std::vector<char *> arr) {
+bool
+is_in(char *val, std::vector<char *> arr)
+{
     for (auto v : arr) {
-    if (val == v) {
+        if (val == v) { return true; }
-      return true;
-    }
     }
     return false;
 }
 
 //----------------------------------------------------------
-bool found_enough(std::vector<set_t> sets, uint64_t set_cnt, size_t set_size) {
+bool
+found_enough(std::vector<set_t> sets, uint64_t set_cnt, size_t set_size)
+{
 
     size_t found_sets = 0;
 
     for (int i = 0; i < sets.size(); i++) {
         set_t curr_set = sets[i];
-    if (curr_set.size() > set_size) {
+        if (curr_set.size() > set_size) { found_sets += 1; }
-      found_sets += 1;
-    }
     }
 
     if (found_sets > set_cnt) {
-    fprintf(
+        fprintf(stderr, "[ERROR] - Found too many sets. Is %ld the correct number of sets?\n", set_cnt);
-        stderr,
-        "[ERROR] - Found too many sets. Is %ld the correct number of sets?\n",
-        set_cnt);
         exit(1);
     }
 
     return (found_sets >= (set_cnt * SET_THRESH)) ? true : false;
 }
 
-void filter_sets(std::vector<set_t> &sets, size_t set_size) {
+void
+filter_sets(std::vector<set_t> &sets, size_t set_size)
+{
 
-  for (auto s = sets.begin(); s < sets.end(); s++) {
+    for (auto s = sets.begin(); s < sets.end();) {
         if (s->size() < set_size) {
-      sets.erase(s);
+            s = sets.erase(s);
-      s -= 1;
+            // s -= 1;
+        } else {
+            ++s;
         }
     }
 }
 
-void print_sets(std::vector<set_t> sets) {
+void
+print_sets(std::vector<set_t> sets)
+{
 
     for (int idx = 0; idx < sets.size(); idx++) {
         fprintf(stderr, "[LOG] - Set: %d\tSize: %ld\n", idx, sets[idx].size());
-    for (auto tmp : sets[idx]) {
+        for (auto tmp : sets[idx]) { fprintf(stderr, "\tv_addr:%p - p_addr:%p\n", tmp.v_addr, (void *) tmp.p_addr); }
-      fprintf(stderr, "\tv_addr:%p - p_addr:%p\n", tmp.v_addr,
-              (void *)tmp.p_addr);
-    }
     }
 }
 
 #ifdef DEBUG_SETS
 
-void verify_sets(std::vector<set_t> &sets, uint64_t threshold, size_t rounds) {
+void
+verify_sets(std::vector<set_t> &sets, uint64_t threshold, size_t rounds)
+{
 
     for (auto s : sets) {
         // test every address against all the addresses in the set
         for (auto tp_base = s.begin(); tp_base < s.end(); tp_base++) {
             uint64_t conflicts = 0;
             for (auto tp_probe = s.begin(); tp_probe < s.end(); tp_probe++) {
-        if (tp_base == tp_probe)
+                if (tp_base == tp_probe) continue;
-          continue;
 
-        uint64_t time = time_tuple((volatile char *)tp_base->v_addr,
+                uint64_t time =
-                                   (volatile char *)tp_probe->v_addr, rounds);
+                    time_tuple((volatile char *) tp_base->v_addr, (volatile char *) tp_probe->v_addr, rounds);
-        if (time > threshold) {
+                if (time > threshold) { conflicts += 1; }
-          conflicts += 1;
-        }
             }
             if (!(conflicts > VALID_THRESH * s.size())) {
                 fprintf(stderr, "[ LOG ] - Removing: %p\n", tp_base->v_addr);
-        s.erase(tp_base--); // reset the iterator
+                s.erase(tp_base--);// reset the iterator
             }
         }
     }

drama/src/utils.c

@@ -1,28 +1,27 @@
-#include <sys/types.h>
+#include <assert.h>
-#include <sys/stat.h>
+#include <errno.h>
-#include <sys/mman.h>
 #include <fcntl.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <assert.h>
 #include <string.h>
+#include <sys/mman.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
 
 #include "utils.h"
 
-
 //-----------------------------------------------
 // 			Memory alloc
 
-int alloc_buffer(mem_buff_t* mem) {
+int
-	if (mem->buffer != NULL) {
+alloc_buffer(mem_buff_t *mem)
-		fprintf(stderr, "[ERROR] - Memory already allocated\n");
+{
-	}
+    if (mem->buffer != NULL) { fprintf(stderr, "[ERROR] - Memory already allocated\n"); }
 
     uint64_t alloc_flags = MAP_PRIVATE | MAP_POPULATE | MAP_ANONYMOUS;
 
-	mem->buffer = (char*) mmap(NULL, mem->size, PROT_READ | PROT_WRITE, alloc_flags, -1, 0);
+    mem->buffer          = (char *) mmap(NULL, mem->size, PROT_READ | PROT_WRITE, alloc_flags, -1, 0);
     if (mem->buffer == MAP_FAILED) {
         perror("[ERROR] - mmap() failed");
         exit(1);
@@ -35,49 +34,47 @@ int alloc_buffer(mem_buff_t* mem) {
         fprintf(stderr, "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
     }
     return 0;
-
 }
 
-
+int
-
+free_buffer(mem_buff_t *mem)
-int free_buffer(mem_buff_t* mem) {
+{
     return munmap(mem->buffer, mem->size);
 }
 
-
-
-
-
 //-----------------------------------------------
 // 				Helpers
 
-double mean(uint64_t* vals, size_t size) {
+double
+mean(uint64_t *vals, size_t size)
+{
     uint64_t avg = 0;
-	for (size_t i = 0; i < size; i++) {
+    for (size_t i = 0; i < size; i++) { avg += vals[i]; }
-		avg += vals[i];
+    return ((double) avg) / size;
-	}
-	return ((double)avg) / size;
 }
 
-int gt(const void * a, const void * b) {
+int
-   return ( *(int*)a - *(int*)b );
+gt(const void *a, const void *b)
+{
+    return (*(int *) a - *(int *) b);
 }
 
-uint64_t median(uint64_t* vals, size_t size) {
+uint64_t
+median(uint64_t *vals, size_t size)
+{
     qsort(vals, size, sizeof(uint64_t), gt);
-	return ((size%2)==0) ? vals[size/2] : (vals[(size_t)size/2]+vals[((size_t)size/2+1)])/2;
+    return ((size % 2) == 0) ? vals[size / 2] : (vals[(size_t) size / 2] + vals[((size_t) size / 2 + 1)]) / 2;
 }
 
-
+char *
-char* bit_string(uint64_t val) {
+bit_string(uint64_t val)
+{
     static char bit_str[256];
     char itoa_str[8];
     strcpy(bit_str, "");
     for (int shift = 0; shift < 64; shift++) {
         if ((val >> shift) & 1) {
-			if (strcmp(bit_str, "") != 0) {
+            if (strcmp(bit_str, "") != 0) { strcat(bit_str, "+ "); }
-				strcat(bit_str, "+ ");
-			}
             sprintf(itoa_str, "%d ", shift);
             strcat(bit_str, itoa_str);
         }