void NicAccumulator::compute_statistics()
{
double current_time = current_time_();
double delta_time = current_time - prev_time_;
double current_rx_bytes = 0;
double current_tx_bytes = 0;
for( NicStates::const_iterator i=nic_states_.begin(); i!=nic_states_.end(); ++i )
{
// Ignore vlans when computing statistics
if( (*i)->get_vlan().empty() )
{
current_rx_bytes += (*i)->get_rx_bytes();
current_tx_bytes += (*i)->get_tx_bytes();
}
}
if( delta_time > 0 )
{
double delta_rx_bytes = current_rx_bytes - prev_rx_bytes_;
double delta_tx_bytes = current_tx_bytes - prev_tx_bytes_;
throughput_ = (delta_rx_bytes + delta_tx_bytes) / (delta_time * BYTES_PER_MEGABYTE);
}
prev_rx_bytes_ = current_rx_bytes;
prev_tx_bytes_ = current_tx_bytes;
prev_time_ = current_time;
}
// NEW: Update this to publish odometry topic
void DiffDrivePlugin6W::publish_odometry()
{
// get current time
ros::Time current_time_((world->GetSimTime()).sec, (world->GetSimTime()).nsec);
// getting data for base_footprint to odom transform
math::Pose pose = link->GetWorldPose();
math::Vector3 velocity = link->GetWorldLinearVel();
math::Vector3 angular_velocity = link->GetWorldAngularVel();
btQuaternion qt(pose.rot.x, pose.rot.y, pose.rot.z, pose.rot.w);
btVector3 vt(pose.pos.x, pose.pos.y, pose.pos.z);
tf::Transform base_footprint_to_odom(qt, vt);
transform_broadcaster_->sendTransform(tf::StampedTransform(base_footprint_to_odom,
current_time_,
"odom",
"base_footprint"));
// publish odom topic
odom_.pose.pose.position.x = pose.pos.x;
odom_.pose.pose.position.y = pose.pos.y;
odom_.pose.pose.orientation.x = pose.rot.x;
odom_.pose.pose.orientation.y = pose.rot.y;
odom_.pose.pose.orientation.z = pose.rot.z;
odom_.pose.pose.orientation.w = pose.rot.w;
odom_.twist.twist.linear.x = velocity.x;
odom_.twist.twist.linear.y = velocity.y;
odom_.twist.twist.angular.z = angular_velocity.z;
odom_.header.frame_id = tf::resolve(tf_prefix_, "odom");
odom_.child_frame_id = "base_footprint";
odom_.header.stamp = current_time_;
pub_.publish(odom_);
}
int
evaluator_online(char *dir, const int *eval_inputs, int num_eval_inputs,
int num_chained_gcs, ChainingType chainingType,
uint64_t *tot_time, uint64_t *tot_time_no_load)
{
/* Performs the online stage of the evaluator.
* The first part of the function loads data from disk
* that was saved during the online phase.
* Next, perform OT correction to acquire input labels
* corresponding to the evaluators' inputs.
* Next, receive instructions on how to evaluate and chain
* the garbled circuits.
* Next, receive garbler labels and the output instructions.
* The output instructions are unary gates mapping output labels to 0 or 1.
* Next, we call evaluator_evaluate to evaluate the garbled circuits using
* the information acquired.
* Finally, use the output instructions to process the output of the
* evaluation subprocedure to acquire actual bits of the output.
*
* @param dir the director which OT and gc data are saved during the offline phase
* @param eval_inputs an array of the evaluator's inputs; either 0 or 1
* @param num_eval_inputs the length of the eval_inputs array
* @param num_chained_gcs the number of garbled circuits saved to disk.
* @param chainingType indicates whether to do standard or SIMD-style chaining.
* WARNING: SIMD-style chaining is deprecated.
* @param tot_time an unpopulated int* (of length 1). evaluator_online populates
* value with the total amount of time it took to evaluate.
* @param tot_time_no_load an unpopulated int* (of length 1). evaluator_online populates
* value with the total amount of time it took to evaluate, not including
* the time to load data from disk.
*/
ChainedGarbledCircuit* chained_gcs;
FunctionSpec function;
block *garb_labels = NULL, *eval_labels = NULL,
*outputmap = NULL, *offsets = NULL;
int *corrections = NULL, *circuitMapping, sockfd;
uint64_t start, end, _start, _end, loading_time;
int num_garb_inputs = 0; /* later received from garbler */
size_t tmp;
block *labels[num_chained_gcs + 1];
/* start timing after socket connection */
_start = current_time_();
{
/* Load things from disk */
chained_gcs = calloc(num_chained_gcs, sizeof(ChainedGarbledCircuit));
loadChainedGarbledCircuits(chained_gcs, num_chained_gcs, dir, chainingType);
loadOTPreprocessing(&eval_labels, &corrections, dir);
for (int i = 1; i < num_chained_gcs + 1; i++) {
labels[i] = garble_allocate_blocks(chained_gcs[i-1].gc.n);
}
}
_end = current_time_();
loading_time = _end - _start;
fprintf(stderr, "Load components: %llu\n", (_end - _start));
if ((sockfd = net_init_client(HOST, PORT)) == FAILURE) {
perror("net_init_client");
exit(EXIT_FAILURE);
}
start = current_time_();
/* Receive eval labels: OT correction */
_start = current_time_();
if (num_eval_inputs > 0) {
block *recvLabels;
uint64_t _start, _end;
for (int i = 0; i < num_eval_inputs; ++i) {
assert(corrections[i] == 0 || corrections[i] == 1);
assert(eval_inputs[i] == 0 || eval_inputs[i] == 1);
corrections[i] ^= eval_inputs[i];
}
recvLabels = garble_allocate_blocks(2 * num_eval_inputs);
/* valgrind is saying corrections is unitialized, but it seems to be */
_start = current_time_();
{
net_send(sockfd, corrections, sizeof(int) * num_eval_inputs, 0);
}
_end = current_time_();
fprintf(stderr, "OT correction (send): %llu\n", _end - _start);
_start = current_time_();
{
tmp = g_bytes_received;
net_recv(sockfd, recvLabels, sizeof(block) * 2 * num_eval_inputs, 0);
}
_end = current_time_();
fprintf(stderr, "OT correction (receive): %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
for (int i = 0; i < num_eval_inputs; ++i) {
eval_labels[i] = garble_xor(eval_labels[i],
recvLabels[2 * i + eval_inputs[i]]);
}
free(recvLabels);
}
free(corrections);
_end = current_time_();
fprintf(stderr, "OT correction: %llu\n", _end - _start);
/* Receive circuit mapping which maps instructions-gc-id to disk-gc-id */
_start = current_time_();
{
int size;
tmp = g_bytes_received;
net_recv(sockfd, &size, sizeof(int), 0);
circuitMapping = malloc(sizeof(int) * size);
net_recv(sockfd, circuitMapping, sizeof(int) * size, 0);
}
_end = current_time_();
fprintf(stderr, "Receive circuit map: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
/* receive garbler labels */
_start = current_time_();
{
tmp = g_bytes_received;
net_recv(sockfd, &num_garb_inputs, sizeof(int), 0);
if (num_garb_inputs > 0) {
garb_labels = garble_allocate_blocks(sizeof(block) * num_garb_inputs);
net_recv(sockfd, garb_labels, sizeof(block) * num_garb_inputs, 0);
}
}
_end = current_time_();
fprintf(stderr, "Receive garbler labels: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
/* Receive output instructions */
OutputInstructions output_instructions;
_start = current_time_();
{
tmp = g_bytes_received;
net_recv(sockfd, &output_instructions.size,
sizeof(output_instructions.size), 0);
output_instructions.output_instruction =
malloc(output_instructions.size * sizeof(OutputInstruction));
net_recv(sockfd, output_instructions.output_instruction,
output_instructions.size * sizeof(OutputInstruction), 0);
}
_end = current_time_();
fprintf(stderr, "Receive output instructions: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
_start = current_time_();
{
tmp = g_bytes_received;
recvInstructions(sockfd, &function.instructions, &offsets);
}
_end = current_time_();
fprintf(stderr, "Receive instructions: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
/* Done with socket, so close */
close(sockfd);
/* Follow instructions and evaluate */
_start = current_time_();
block **computedOutputMap = malloc(sizeof(block *) * (num_chained_gcs + 1));
{
computedOutputMap[0] = garble_allocate_blocks(num_garb_inputs + num_eval_inputs);
labels[0] = garble_allocate_blocks(num_garb_inputs + num_eval_inputs);
memcpy(&computedOutputMap[0][0], garb_labels, sizeof(block) * num_garb_inputs);
memcpy(&computedOutputMap[0][num_garb_inputs], eval_labels, sizeof(block) * num_eval_inputs);
memcpy(&labels[0][0], garb_labels, sizeof(block) * num_garb_inputs);
memcpy(&labels[0][num_garb_inputs], eval_labels, sizeof(block) * num_eval_inputs);
for (int i = 1; i < num_chained_gcs + 1; i++) {
computedOutputMap[i] = garble_allocate_blocks(chained_gcs[i-1].gc.m);
}
evaluator_evaluate(chained_gcs, num_chained_gcs, &function.instructions,
labels, circuitMapping, computedOutputMap, offsets, chainingType);
}
_end = current_time_();
fprintf(stderr, "Evaluate: %llu\n", _end - _start);
_start = current_time_();
int *output = calloc(output_instructions.size, sizeof(int));
{
int res = computeOutputs(&output_instructions, output, computedOutputMap);
if (res == FAILURE) {
fprintf(stderr, "computeOutputs failed\n");
/* return FAILURE; */
}
}
free(output_instructions.output_instruction);
_end = current_time_();
fprintf(stderr, "Map outputs: %llu\n", _end - _start);
/* cleanup */
free(circuitMapping);
for (int i = 0; i < num_chained_gcs; ++i) {
freeChainedGarbledCircuit(&chained_gcs[i], false, chainingType);
free(labels[i]);
free(computedOutputMap[i]);
computedOutputMap[i] = NULL;
}
//free(labels[num_chained_gcs]);
free(computedOutputMap[num_chained_gcs]);
free(chained_gcs);
free(computedOutputMap);
free(outputmap);
free(output);
free(garb_labels);
free(eval_labels);
if (function.instructions.instr) {
free(function.instructions.instr);
function.instructions.instr = NULL;
}
free(offsets);
end = current_time_();
if (tot_time)
*tot_time = end - start + loading_time;
if (tot_time_no_load)
*tot_time_no_load = end - start;
return SUCCESS;
}
static void
evaluator_evaluate(ChainedGarbledCircuit* chained_gcs, int num_chained_gcs,
const Instructions* instructions, block** labels, const int* circuitMapping,
block **computedOutputMap, const block *offsets, ChainingType chainingType)
{
/* Evaluates the chained garbled circuits using the array of chained_gcs, the instructions,
* input labels, and other information provided. Ignoring abstractions, this
* function populates the array computedOutputMap which holds
* the output blocks of each garbled circuit. With these blocks,
* and extra information on the semantic value of each block
* (i.e. does it represent 0 or 1),
* the evaluator can determine the real output of the component-based gc system.
* Note: the indices provided by CircuitMapping should only used
* when evaluating. In all other places, the indices used to designate the
* chained garbled circuits are consistent with the indices stated in
* the instructions instructions. circuitMapping maps the indice of the instruction
* to the correct index of the chainedGarbledCircuit as saved on disk.
*
* Inputs:
* @param chained_gcs an array of chained garbled circuits that will be evaluated
* @param num_chained_gcs the length of the chained_gcs array
* @param instructions a list of instructions on how to evaluate and chain
* @param labels a 2-d array of the input labels to each garbled circuit
* lables[i] is an array of input labels for chained_gcs[i].
* @param circuitMapping a mapping of garbled circuit indices from those
* used in the instructions to those used to save the garbled circuits to disk.
* @param computedOutputMap a 2-d array of the output labels of each garbled circuit,
* where computedOutputMap[i] is the list of output labels of gc i
* @param offsets otherwise known as the chaining mask, the offsets are the
* blocks needed to map output labels of one gc to input labels of another gc.
*
*/
int savedCircId, offsetIdx;
uint64_t s,e, eval_time = 0;
for (int i = 0; i < instructions->size; i++) {
Instruction* cur = &instructions->instr[i];
switch(cur->type) {
case EVAL:
s = current_time_();
savedCircId = circuitMapping[cur->ev.circId];
garble_eval(&chained_gcs[savedCircId].gc, labels[cur->ev.circId],
computedOutputMap[cur->ev.circId], NULL);
e = current_time_();
eval_time += e - s;
break;
case CHAIN:
if (chainingType == CHAINING_TYPE_STANDARD) {
// if mapping inputs
if (cur->ch.fromCircId == 0) {
int offsetIdx = cur->ch.offsetIdx;
for (int j = cur->ch.fromWireId, k = cur->ch.toWireId;
j < cur->ch.fromWireId + cur->ch.wireDist;
++j, ++k) {
labels[cur->ch.toCircId][k] = garble_xor(
computedOutputMap[cur->ch.fromCircId][j],
offsets[offsetIdx]);
}
} else {
// if not inputs:
block b = garble_xor(
computedOutputMap[cur->ch.fromCircId][cur->ch.fromWireId],
offsets[cur->ch.offsetIdx]);
memcpy(&labels[cur->ch.toCircId][cur->ch.toWireId], &b, sizeof(b));
}
} else {
/* CHAINING_TYPE_SIMD */
savedCircId = circuitMapping[cur->ch.fromCircId];
offsetIdx = cur->ch.offsetIdx;
for (int j = cur->ch.fromWireId, k = cur->ch.toWireId;
j < cur->ch.fromWireId + cur->ch.wireDist;
++j, ++k) {
/* correct computedOutputMap offlineChainingOffsets */
/* i.e. correct to enable SIMD trick */
labels[cur->ch.toCircId][k] = garble_xor(
computedOutputMap[cur->ch.fromCircId][j],
offsets[offsetIdx]);
if (cur->ch.fromCircId != 0) { /* if not the input component */
labels[cur->ch.toCircId][k] = garble_xor(
labels[cur->ch.toCircId][k],
chained_gcs[savedCircId].offlineChainingOffsets[j]);
}
}
}
break;
default:
printf("Error: Instruction %d is not of a valid type\n", i);
return;
}
}
fprintf(stderr, "evaltime: %llu\n", eval_time);
}
void
evaluator_offline(char *dir, int num_eval_inputs, int nchains,
ChainingType chainingType)
{
/* Does the offline stage for the evaluator.
* This includes receiving pre-exchanged garbled circuits,
* performing the offline phase of OT-preprocessing, and
* saving relevant information to disk.
*
* @param dir the directory to save information
* @param num_eval_inputs the number of evaluator inputs
* @param nchains the number of garbled circuits to be pre-exchanged
* @param chainingType indicates whether we are using SIMD or standard chaining.
* WARNING: SIMD-style chaining is now deprecated.
*/
int sockfd;
struct state state;
ChainedGarbledCircuit cgc;
uint64_t start, end;
state_init(&state);
if ((sockfd = net_init_client(HOST, PORT)) == FAILURE) {
perror("net_init_client");
exit(EXIT_FAILURE);
}
start = current_time_();
for (int i = 0; i < nchains; i++) {
chained_gc_comm_recv(sockfd, &cgc, chainingType);
saveChainedGC(&cgc, dir, false, chainingType);
freeChainedGarbledCircuit(&cgc, false, chainingType);
}
/* pre-processing OT using random selection bits */
if (num_eval_inputs > 0) {
int *selections;
block *evalLabels;
char *fname;
size_t size;
selections = malloc(sizeof(int) * num_eval_inputs);
size = strlen(dir) + strlen("/sel") + 1;
fname = malloc(size);
for (int i = 0; i < num_eval_inputs; ++i) {
selections[i] = rand() % 2;
}
evalLabels = garble_allocate_blocks(num_eval_inputs);
ot_np_recv(&state, sockfd, selections, num_eval_inputs, sizeof(block),
2, evalLabels, new_choice_reader, new_msg_writer);
(void) snprintf(fname, size, "%s/%s", dir, "sel");
saveOTSelections(fname, selections, num_eval_inputs);
(void) snprintf(fname, size, "%s/%s", dir, "lbl");
saveOTLabels(fname, evalLabels, num_eval_inputs, false);
free(selections);
free(evalLabels);
free(fname);
}
end = current_time_();
fprintf(stderr, "evaluator offline: %llu\n", (end - start));
close(sockfd);
state_cleanup(&state);
}
void
evaluator_classic_2pc(const int *input, bool *output,
int num_garb_inputs, int num_eval_inputs,
uint64_t *tot_time)
{
/* Does the "full" garbled circuit protocol, wherein there is no online phase.
* The garbled circuit and all input labels are communicated during the
* online phase, although we do use OT-processing
*/
int sockfd;
int *selections = NULL;
garble_circuit gc;
OldInputMapping map;
block *garb_labels = NULL, *eval_labels = NULL;
block *labels, *output_map;
uint64_t start, end, _start, _end;
size_t tmp;
gc.type = GARBLE_TYPE_STANDARD;
if ((sockfd = net_init_client(HOST, PORT)) == FAILURE) {
perror("net_init_client");
exit(EXIT_FAILURE);
}
/* pre-process OT */
if (num_eval_inputs > 0) {
struct state state;
state_init(&state);
selections = calloc(num_eval_inputs, sizeof(int));
eval_labels = garble_allocate_blocks(num_eval_inputs);
for (int i = 0; i < num_eval_inputs; ++i) {
selections[i] = rand() % 2;
}
ot_np_recv(&state, sockfd, selections, num_eval_inputs, sizeof(block),
2, eval_labels, new_choice_reader, new_msg_writer);
state_cleanup(&state);
}
/* Start timing after pre-processing of OT as we only want to record online
* time */
start = current_time_();
_start = current_time_();
{
tmp = g_bytes_received;
gc_comm_recv(sockfd, &gc);
}
_end = current_time_();
fprintf(stderr, "Receive GC: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
_start = current_time_();
tmp = g_bytes_received;
if (num_eval_inputs > 0) {
block *recvLabels;
for (int i = 0; i < num_eval_inputs; ++i) {
selections[i] ^= input[i];
}
recvLabels = garble_allocate_blocks(2 * num_eval_inputs);
net_send(sockfd, selections, sizeof(int) * num_eval_inputs, 0);
net_recv(sockfd, recvLabels, sizeof(block) * 2 * num_eval_inputs, 0);
for (int i = 0; i < num_eval_inputs; ++i) {
eval_labels[i] = garble_xor(eval_labels[i],
recvLabels[2 * i + input[i]]);
}
free(recvLabels);
free(selections);
}
_end = current_time_();
fprintf(stderr, "OT correction: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
_start = current_time_();
tmp = g_bytes_received;
if (num_garb_inputs > 0) {
garb_labels = garble_allocate_blocks(num_garb_inputs);
net_recv(sockfd, garb_labels, sizeof(block) * num_garb_inputs, 0);
}
_end = current_time_();
fprintf(stderr, "Receive garbler labels: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
_start = current_time_();
{
tmp = g_bytes_received;
output_map = garble_allocate_blocks(2 * gc.m);
net_recv(sockfd, output_map, sizeof(block) * 2 * gc.m, 0);
}
_end = current_time_();
fprintf(stderr, "Receive output map: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
_start = current_time_();
tmp = g_bytes_received;
{
size_t size;
char *buffer;
net_recv(sockfd, &size, sizeof size, 0);
buffer = malloc(size);
net_recv(sockfd, buffer, size, 0);
readBufferIntoInputMapping(&map, buffer);
free(buffer);
}
_end = current_time_();
fprintf(stderr, "Receive garbler labels: %llu\n", _end - _start);
fprintf(stderr, "\tBytes: %lu\n", g_bytes_received - tmp);
close(sockfd);
/* Plug labels in correctly based on input_mapping */
{
labels = garble_allocate_blocks(gc.n);
int garb_p = 0, eval_p = 0;
for (int i = 0; i < map.size; i++) {
if (map.inputter[i] == PERSON_GARBLER) {
labels[map.wire_id[i]] = garb_labels[garb_p];
garb_p++;
} else if (map.inputter[i] == PERSON_EVALUATOR) {
labels[map.wire_id[i]] = eval_labels[eval_p];
eval_p++;
}
}
}
_start = current_time_();
{
bool *outputs = calloc(gc.m, sizeof(bool));
garble_eval(&gc, labels, NULL, outputs);
free(outputs);
}
_end = current_time_();
fprintf(stderr, "Evaluate: %llu\n", _end - _start);
garble_delete(&gc);
deleteOldInputMapping(&map);
free(output_map);
free(eval_labels);
free(garb_labels);
free(labels);
end = current_time_();
*tot_time = end - start;
}