Tutorial, linear regression implementation

test/oblivc/linReg/linReg.h

@@ -0,0 +1,22 @@
+// Fixed point arithmetic
+#define SCALE (1 << 16) // 2^16
+#define DESCALE(x) x / SCALE // for use in multiplication
+#define MAXN 1000
+#define SEED 5 // used for osqrt(), adjust for average values of given dataset
+
+typedef struct {
+  char *src; // filename for data read
+  int n; // number of data points
+  int m; // slope
+  int b; // y-intercept
+  int r; // correlation
+} protocolIO;
+
+// Collect runtime information
+extern double lap;
+double wallClock();
+const char* mySide();
+
+void linReg(void* args);
+void load_data(protocolIO *io, int x[MAXN], int y[MAXN], int party);
+void write_runtime(int n, double time, int party, const char* dest);

test/oblivc/olinReg/Makefile

@@ -0,0 +1,28 @@
+testName=linReg
+LOADLIBES = -lm
+PORT=1234
+REMOTE_HOST=localhost
+CONNECTION = $(REMOTE_HOST):$(PORT)
+TX = tx.dat
+TY = ty.dat
+
+$(if $(testName),,$(error 'testName' must be defined before Makefile.simple is used))
+CILPATH=../../../
+CFLAGS=-O3 -g -Wall
+./a.out: $(testName).oc $(testName).c ../common/util.c $(CILPATH)/obj/x86_LINUX/libobliv.a
+	$(CILPATH)/bin/oblivcc $(CFLAGS) -I . $(testName).oc $(testName).c ../common/util.c $(LOADLIBES)
+
+clean:
+	rm -f a.out $(testName).oc.cil.i $(testName).oc.i $(testName).oc.cil.c runtime.dat
+
+# Run tests quickly
+t1:
+	$(./a.out)
+	./a.out $(CONNECTION) 1 $(TX)
+
+t2:
+	$(./a.out) 
+	./a.out $(CONNECTION) 2 $(TY)
+
+# REMOTE_HOST = localhost 
+# -DREMOTE_HOST=$(#REMOTE_HOST)

test/oblivc/olinReg/README.md

@@ -0,0 +1,12 @@
+# Linear-Regression
+Secure MPC version of linear regression function using [Obliv-C language](http://www.oblivc.org); C code is based off of [this](https://www.github.com/samuelhavron/linear-regression) repository. Party 1 supplies independent ([x](testx.dat)) data points; party 2 supplies dependent ([y](testy.dat)) data points. Runtime information and code optimizations currently in development. Sample tests using publicly released datasets currently in development.
+
+# Usage Notes
+If running a remote connection, party 1 (the listener) does not need to supply party 2's IP address or DNS name (as party 2 is connecting to the listener).
+
+Random test data can be generated with `python gendat.py tx.dat ty.dat txy.dat <number_of_points>`. To quickly run the test data over a local network, targets t1 and t2 are included in the [Makefile](Makefile). Run `make` on both shells, then `make t1` on shell with independent (x) points and then `make t2` on shell with dependent (y) points.
+
+Does not compute data values over 32,000 currently. Adjust implementation for long long ints if needed.
+
+If using EC2 on AWS to compute data:
+Add desired TCP port as a custom inbound rule to each AMI nodes' security group before running. Use Public IP or DNS name for hostname in runtime argument.

test/oblivc/olinReg/dbg.h

@@ -0,0 +1,23 @@
+// Code adapted from http://www.c.learncodethehardway.org/book/ex20.html
+// Original Author: Zed Shaw
+
+#ifndef __dbg_h__
+#define __dbg_h__
+
+#include <stdio.h>
+#include <errno.h>
+#include <string.h>
+
+#ifdef NDEBUG
+#define debug(M, ...)
+#else
+#define debug(M, ...) fprintf(stderr, "DEBUG %s:%s:L%d: " M "\n", __FILE__, __FUNCTION__, __LINE__, ##__VA_ARGS__)
+#endif
+
+#define clean_errno() (errno == 0 ? "None" : strerror(errno))
+
+#define log_err(M, ...) fprintf(stderr, "[ERROR] (%s:%s:L%d: errno: %s) " M, __FILE__, __FUNCTION__, __LINE__, clean_errno(), ##__VA_ARGS__)
+
+#define log_info(M, ...) fprintf(stderr, "[INFO] (%s:%s:L%d) " M, __FILE__, __FUNCTION__, __LINE__, ##__VA_ARGS__)
+
+#endif

test/oblivc/olinReg/gendat.py

@@ -0,0 +1,37 @@
+# Samuel Havron
+# https://www.github.com/samuelhavron
+# MIT License
+
+from sys import argv
+import random
+
+try:
+    script, filenameX, filenameY, filenameXY, data_points = argv
+except ValueError:
+    print "Usage: python %s <xfile> <yfile> <xycatfile> <number_of_points>" % argv[0]
+    quit()
+
+print "Generating %d random data points in %s, %s, and %s" % (
+    int(data_points), filenameX, filenameY, filenameXY)
+
+fx = open(filenameX, 'w')
+fy = open(filenameY, 'w')
+fxy = open(filenameXY, 'w')
+fx.truncate()
+fy.truncate()
+fxy.truncate()
+
+xr = 0.0
+for i in xrange(0, int(data_points)):
+    xr += round(random.uniform(0, 1000), 4)
+    yr = xr + round(random.uniform(0, 5), 2) # create artificial correlation
+    if (xr >= 32000 or yr >= 32000):
+        xr -= round(random.uniform(1000, 10000), 4)
+        yr -= round(random.uniform(1000, 10000), 4)
+    print>>fx, xr
+    print>>fy, yr
+    print>>fxy, "%f %f" % (xr, yr)
+
+fx.close()
+fy.close()
+fxy.close()

test/oblivc/olinReg/linReg.c

@@ -0,0 +1,149 @@
+// Samuel Havron <havron@virginia.edu>
+// https://www.github.com/samuelhavron
+// MIT License
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <assert.h>
+#include "linReg.h"
+#include <obliv.h>
+#include "../common/util.h"
+#include "dbg.h"
+
+double lap;
+int currentParty;
+
+const char* mySide() {
+  if (currentParty == 1) return "Generator";
+  else return "Evaluator";
+}
+
+int main(int argc, char *argv[]) {
+  printf("Linear Regression\n");
+  printf("=================\n\n");
+
+  // Check args
+  if (argc == 4) {
+
+    // Initialize protocols and obtain connection information
+    const char *remote_host = strtok(argv[1], ":");
+    const char *port = strtok(NULL, ":");
+    ProtocolDesc pd;
+    protocolIO io;
+
+    // Make connection between two shells
+    // Modified ocTestUtilTcpOrDie() function from ~/obliv-c/test/oblivc/common/util.c
+    log_info("Connecting to %s on port %s ...\n", remote_host, port);
+    if(argv[2][0] == '1') { 
+      if(protocolAcceptTcp2P(&pd,port)!=0) { 
+	log_err("TCP accept from %s failed\n", remote_host);
+	exit(1);
+      }
+    }
+    else {
+      if(protocolConnectTcp2P(&pd,remote_host,port)!=0) {
+	log_err("TCP connect to %s failed\n", remote_host);
+	exit(1);
+	}
+    }
+
+    // Final initializations before entering Yao protocol
+    currentParty = (argv[2][0]=='1'?1:2);
+    setCurrentParty(&pd, currentParty); // only checks for a '1'
+    io.src = argv[3]; // filename
+    lap = wallClock();
+
+    // Execute Yao protocol and cleanup
+    execYaoProtocol(&pd, linReg, &io); // starts 'linReg()'
+    cleanupProtocol(&pd);
+    double runtime = wallClock() - lap; // stop clock here 
+
+    // Print results and store runtime data
+    log_info("%s total time: %lf seconds\n", mySide(), runtime);
+    log_info("Yao Gate Count: %u\n", yaoGateCount());
+    write_runtime(io.n, runtime, currentParty, "runtime.dat");
+
+    printf("\n");
+    log_info("Slope   \tm = %15.6e\n", (double) DESCALE(io.m)); // print slope
+    log_info("y-intercept\tb = %15.6e\n", (double) DESCALE(io.b)); // print y-intercept
+    log_info("Correlation\tr = %15.6e\n", sqrt((double) DESCALE(io.rsqr))); // print correlation
+  } else {
+    log_info("Usage: %s <hostname:port> <1|2> <filename>\n" 
+	     "\tHostname usage:\n" 
+	     "\tlocal -> 'localhost' remote -> IP address or DNS name\n", argv[0]);
+  }
+  return 0;
+}
+
+void load_data(protocolIO *io, int** x, int** y, int party) {
+  FILE *inputFile = fopen(io->src, "r");
+
+  if (inputFile == NULL) {
+   log_err("File '%s' not found\n", io->src);
+   clean_errno();
+   exit(1); // causes TCP error for non-null party
+  }
+
+  io->n = 0;
+  int memsize = ALLOC;
+
+  double a;
+  while (!feof(inputFile)) {
+    int dataPoints = fscanf(inputFile, "%lf", &a);
+
+    if (dataPoints != 1) {
+      if (dataPoints < 0 && feof(inputFile)) {
+	break;
+      } else {
+	log_err("Input from '%s' does not match file format. Check input file.\n\t" 
+		"File format exception found at Line %d or %d in file.\n", 
+		io->src, io->n, io->n + 1); // prints to both parties if filename is same
+	clean_errno();
+	exit(1);
+      }
+    }
+
+    io->n += 1;
+    if (io->n > memsize) {
+      memsize *= 2;
+      *x = realloc(*x, sizeof(int) * memsize);
+      *y = realloc(*y, sizeof(int) * memsize);
+      check_mem(*x, *y, party);
+    }
+
+    int aint = a * SCALE;
+    assert(APPROX((double) DESCALE(aint), a));
+    if (party == 1) {
+      *(*x + io->n - 1) =  aint; // messy, but needed for dereferencing 
+    } else if (party == 2) {
+      *(*y + io->n - 1) =  aint;
+    }
+
+  }
+
+  log_info("Loading %d data points ...\n", io->n);
+  fclose(inputFile);
+}
+
+void write_runtime(int n, double time, int party, const char* dest) {
+  FILE *file = fopen(dest, "a");
+
+  if (file == NULL) {
+    log_err("File '%s' not found\n", dest);
+    clean_errno();
+    exit(1);
+  }
+
+  fprintf(file, "[party %d] %d points, %lf seconds\n", party, n, time);
+  log_info("Runtime data stored in file '%s'\n", dest);
+}
+
+void check_mem(int* x, int* y, int party) {
+  if((party == 1 && x == NULL) || (party == 2 && y == NULL)) {
+    log_err("Memory allocation failed\n");
+    clean_errno();
+    exit(1);
+  }
+}

test/oblivc/olinReg/linReg.h

@@ -0,0 +1,26 @@
+// Fixed point arithmetic
+#define SCALE (1 << 16) // 2^16
+#define DESCALE(x) x / SCALE // for use in multiplication
+#define ALLOC 128 // initial malloc amount, doubled when needed in load_data()
+#define APPROX(x, y) fabs(x - y) < EPSILON
+#define EPSILON 2
+
+typedef struct {
+  char *src; // filename for data read
+  int n; // number of data points
+  int m; // slope
+  int b; // y-intercept
+
+  int rsqr; // correlation numerator, cov^2 / variances
+  int r; // correlation
+} protocolIO;
+
+// Collect runtime information
+extern double lap;
+double wallClock();
+const char* mySide();
+
+void linReg(void* args);
+void load_data(protocolIO *io, int** x, int** y, int party);
+void write_runtime(int n, double time, int party, const char* dest);
+void check_mem(int* x, int* y, int party);