update receiver footprint and add benchmark function

Author: 0x161e-swei

receiver.c

@@ -13,7 +13,7 @@ void init_config(struct config *config, int argc, char **argv) {
         // 4096 L1 stride
         int L1_way_stride = ipow(2, LOG_CACHE_SETS_L1 + LOG_CACHE_LINESIZE);
         // (4 * 64) * 8 * 4k = 8M
-        uint64_t bsize = 256 * CACHE_WAYS_L1 * L1_way_stride;
+        uint64_t bsize = 512 * CACHE_WAYS_L1 * L1_way_stride;
 
         // Allocate a buffer twice the size of the L1 cache
         config->buffer = allocate_buffer(bsize);
@@ -26,7 +26,7 @@ void init_config(struct config *config, int argc, char **argv) {
         // Construct the addr_set by taking the addresses that have cache set index 0
         // There will be at least one of such addresses in our buffer.
         uint32_t addr_set_size = 0;
-        for (int i = 0; i < 256 * CACHE_WAYS_L1 * CACHE_SETS_L1; i++) {
+        for (int i = 0; i < 512 * CACHE_WAYS_L1 * CACHE_SETS_L1; i++) {
             ADDR_PTR addr = (ADDR_PTR) (config->buffer + CACHE_LINESIZE * i);
             // both of following function should work...L3 is a more restrict set
             if (get_cache_slice_set_index(addr) == config->cache_region) {
@@ -40,7 +40,7 @@ void init_config(struct config *config, int argc, char **argv) {
             }
             // more lines than private cache ways helps to put more lines
             // into llc slices, increasing chance of to conflict with sender
-            else if (addr_set_size >= 3 * (CACHE_WAYS_L1 + CACHE_WAYS_L2)) {
+            else if (addr_set_size >= 5 * (CACHE_WAYS_L1 + CACHE_WAYS_L2)) {
                 break;
             }
         }
@@ -188,10 +188,58 @@ bool detect_bit_pp(const struct config *config, bool first_bit)
 // to be the same as the max size of the message in the starter code of the sender.
 // static const int MAX_BUFFER_LEN = 128 * 8;
 
+void benchmark_receive(struct config *config_p) {
+    uint32_t benchmarkSize = 8192;
+    uint8_t *msg = (uint8_t *)malloc(sizeof(uint8_t) * benchmarkSize);
+    uint64_t start_t, bench_start_t = 0, bench_end_t = 0;
+    for (uint32_t i = 0; i < benchmarkSize; i++) {
+        // sync every 1024 bits, detecting pilot signal again
+        if ((i & 0x3ff) == 0) {
+            bool curr = true, prev = true;
+            int flip_sequence = 4;
+            while (true) {
+                start_t = cc_sync();
+                curr = detect_bit(config_p, true);
+
+                if (flip_sequence == 0 && curr == 1 && prev == 1) {
+                    debug("pilot signal detected for round %u\r", i / 1024);
+                    start_t = cc_sync();
+                    bench_start_t = i == 0? start_t: bench_start_t;
+                    break;
+                }
+                else if (flip_sequence > 0 && curr != prev) {
+                    flip_sequence--;
+                }
+        else if (curr == prev) {
+                    flip_sequence = 4;
+                }
+                prev = curr;
+            }
+        }
+
+        msg[i] = detect_bit(config_p, true);
+
+    }
+    bench_end_t = get_time();
+    printf("total cycles to receive %u bits is %lu\n", benchmarkSize,
+        bench_end_t - bench_start_t);
+
+    if (msg) {
+        FILE *receiverSave = fopen("receiverSave", "w+");
+        for (uint32_t i = 0; i < benchmarkSize; i++) {
+            fprintf(receiverSave, "%u %u\n", i, msg[i]);
+        }
+        fclose(receiverSave);
+
+        free(msg);
+    }
+}
+
 int main(int argc, char **argv)
 {
     // Initialize config and local variables
     struct config config;
+
     init_config(&config, argc, argv);
     if (config.channel == PrimeProbe || config.channel == L1DPrimeProbe) {
         detect_bit = detect_bit_pp;
@@ -206,6 +254,11 @@ int main(int argc, char **argv)
     bool current;
     bool previous = true;
 
+    if (config.benchmark_mode) {
+        benchmark_receive(&config);
+        exit(0);
+    }
+
     printf("Press enter to begin listening ");
     getchar();
     while (1) {

sender.c

@@ -156,6 +156,53 @@ void send_bit_pp(bool one, const struct config *config)
     }
 }
 
+uint8_t *generate_random_msg(uint32_t size) {
+    uint8_t *msg = (uint8_t *)malloc(sizeof(uint8_t) * size);
+    srand(time(NULL));
+    for(uint32_t i = 0; i < size; i++) {
+        int randomnum = rand();
+        msg[i] = (randomnum > RAND_MAX/2);
+    }
+    return msg;
+}
+
+void benchmark_send(struct config *config_p) {
+    uint32_t benchmarkSize = 8192;
+    uint8_t *randomMsg = generate_random_msg(benchmarkSize);
+    uint64_t start_t;
+
+    for (uint32_t i = 0; i < benchmarkSize; i++) {
+        // sync every 1024 bits
+        if ((i & 0x3ff) == 0) {
+            for (int j = 0; j < 10; j++) {
+                start_t = cc_sync();
+                send_bit(j % 2 == 0, config_p);
+            }
+
+            start_t = cc_sync();
+            send_bit(true, config_p);
+
+            start_t = cc_sync();
+            send_bit(true, config_p);
+
+            // Send the message bit by bit
+            debug("pilot signal sentt for round %u\r", i / 1024);
+            start_t = cc_sync();
+        }
+        send_bit(randomMsg[i], config_p);
+    }
+
+    if (randomMsg) {
+        FILE *senderSave = fopen("senderSave", "w+");
+        for (uint32_t i = 0; i < benchmarkSize; i++) {
+            fprintf(senderSave, "%u %u\n", i, randomMsg[i]);
+        }
+        fclose(senderSave);
+
+        free(randomMsg);
+    }
+}
+
 int main(int argc, char **argv)
 {
     // Initialize config and local variables
@@ -168,17 +215,28 @@ int main(int argc, char **argv)
         send_bit = send_bit_fr;
     }
 
+    if (config.benchmark_mode) {
+        benchmark_send(&config);
+        exit(0);
+    }
+
     uint64_t start_t, end_t;
     int sending = 1;
     printf("Please type a message (exit to stop).\n");
+
+#if 0
     char all_one_msg[129];
     for (uint32_t i = 0; i < 120; i++)
         all_one_msg[i] = '1';
     for (uint32_t i = 120; i < 128; i++)
         all_one_msg[i] = '1';
     all_one_msg[128] = '\0';
+#endif
+
     while (sending) {
-#if 1
+#if 0
+        char *msg = all_one_msg;
+#else
         // Get a message to send from the user
         printf("< ");
         char text_buf[128];
@@ -189,8 +247,6 @@ int main(int argc, char **argv)
         }
 
         char *msg = string_to_binary(text_buf);
-#else
-        char *msg = all_one_msg;
 #endif
 
         // If we are in benchmark mode, start measuring the time

util.c

@@ -42,11 +42,11 @@ uint64_t rdtsc() {
 
 extern inline __attribute__((always_inline))
 CYCLES rdtscp(void) {
-	CYCLES cycles;
-	asm volatile ("rdtscp"
-	: /* outputs */ "=a" (cycles));
+    CYCLES cycles;
+    asm volatile ("rdtscp"
+    : /* outputs */ "=a" (cycles));
 
-	return cycles;
+    return cycles;
 }
 
 inline uint64_t get_time() {
@@ -109,7 +109,7 @@ void *allocate_buffer(uint64_t size) {
 #endif
 
     if (buffer == MAP_FAILED) {
-        fprintf(stderr, "allocating non-hugepages\n");
+        fprintf(stderr, "WARNING: allocating non-hugepages\n");
         buffer = mmap(NULL, size, PROT_READ|PROT_WRITE, MAP_ANON|MAP_PRIVATE, -1, 0);
     }
     if (buffer == MAP_FAILED) {
@@ -200,7 +200,15 @@ uint64_t print_pid() {
 }
 
 void print_help() {
-    // TODO
+    printf("======================= H E L P ===============================\n");
+    printf("-c: (uint 0 to 2) to select a channel\n");
+    printf("-i: (uint) to specify a interval for each bit transmission\n");
+    printf("-p: (uint) to specify a time period for prime (for llc-pp)\n");
+    printf("-a: (uint) to specify a time period for access (for llc-pp)\n");
+    printf("-r: (uint) to specify a LLC cache set to contend on\n");
+    printf("-b: to start benchmark mode (default is chat mode)\n");
+    printf("-h: to print this message\n");
+    printf("===============================================================\n");
 }
 
 void init_default(struct config *config, int argc, char **argv) {
@@ -224,30 +232,31 @@ void init_default(struct config *config, int argc, char **argv) {
 
     config->channel = PrimeProbe;
 
-    // Parse the command line flags
-    //      -d is used to enable the debug prints
-    //      -i is used to specify a custom value for the time interval
-    //      -w is used to specify a custom number of wait time between two probes
     int option;
-    while ((option = getopt(argc, argv, "di:a:r:c:")) != -1) {
+    while ((option = getopt(argc, argv, "c:i:p:a:r:bh")) != -1) {
         switch (option) {
+            case 'c':
+                // value 0,1,2 to select channel
+                config->channel = atoi(optarg);
+                break;
             case 'i':
                 config->interval = atoi(optarg);
                 break;
-            case 'r':
-                config->cache_region = atoi(optarg);
+            case 'p':
+                config->prime_period = atoi(optarg);
                 break;
             case 'a':
                 config->access_period = atoi(optarg);
                 break;
-            case 'c':
-                // value 0,1,2 to select channel
-                config->channel = atoi(optarg);
+            case 'r':
+                config->cache_region = atoi(optarg);
+                break;
+            case 'b':
+                config->benchmark_mode = true;
                 break;
             case '?':
                 fprintf(stderr, "Unknown option character `\\x%x'.\n", optopt);
-                print_help();
-                exit(1);
+            case 'h':
             default:
                 print_help();
                 exit(1);