def run(args, options, param=-1, merge_opens=True, \
reallocate=True, debug=False):
""" Compile a file and output a Program object.
If merge_opens is set to True, will attempt to merge any parallelisable open
instructions. """
prog = Program(args, options, param)
instructions.program = prog
instructions_base.program = prog
types.program = prog
comparison.program = prog
prog.DEBUG = debug
VARS['program'] = prog
comparison.set_variant(options)
print 'Compiling file', prog.infile
if instructions_base.Instruction.count != 0:
print 'instructions count', instructions_base.Instruction.count
instructions_base.Instruction.count = 0
prog.FIRST_PASS = False
prog.reset_values()
# make compiler modules directly accessible
sys.path.insert(0, 'Compiler')
# create the tapes
execfile(prog.infile, VARS)
# optimize the tapes
for tape in prog.tapes:
tape.optimize(options)
if prog.main_thread_running:
prog.update_req(prog.curr_tape)
print 'Program requires:', repr(prog.req_num)
print 'Memory size:', prog.allocated_mem
# finalize the memory
prog.finalize_memory()
return prog
def run(filename, options, param=-1, merge_opens=True, emulate=True, \
reallocate=True, assemblymode=False, debug=False):
""" Compile a file and output a Program object.
If merge_opens is set to True, will attempt to merge any parallelisable open
instructions. """
prog = Program(filename, options, param, assemblymode)
instructions.program = prog
instructions_base.program = prog
types.program = prog
comparison.program = prog
prog.EMULATE = emulate
prog.DEBUG = debug
VARS['program'] = prog
comparison.set_variant(options)
print 'Compiling file', prog.infile
# no longer needed, but may want to support assembly in future (?)
if assemblymode:
prog.restart_main_thread()
for i in xrange(INIT_REG_MAX):
VARS['c%d'%i] = prog.curr_block.new_reg('c')
VARS['s%d'%i] = prog.curr_block.new_reg('s')
VARS['cg%d'%i] = prog.curr_block.new_reg('cg')
VARS['sg%d'%i] = prog.curr_block.new_reg('sg')
if i % 10000000 == 0 and i > 0:
print "Initialized %d register variables at" % i, time.asctime()
# first pass determines how many assembler registers are used
prog.FIRST_PASS = True
execfile(prog.infile, VARS)
if instructions_base.Instruction.count != 0:
print 'instructions count', instructions_base.Instruction.count
instructions_base.Instruction.count = 0
prog.FIRST_PASS = False
prog.reset_values()
# make compiler modules directly accessible
sys.path.insert(0, 'Compiler')
# create the tapes
execfile(prog.infile, VARS)
# optimize the tapes
for tape in prog.tapes:
tape.optimize(options)
# check program still does the same thing after optimizations
if emulate:
clearmem = list(prog.mem_c)
sharedmem = list(prog.mem_s)
prog.emulate()
if prog.mem_c != clearmem or prog.mem_s != sharedmem:
print 'Warning: emulated memory values changed after compiler optimization'
# raise CompilerError('Compiler optimization caused incorrect memory write.')
if prog.main_thread_running:
prog.update_req(prog.curr_tape)
print 'Program requires:', repr(prog.req_num)
#print 'Cost:', prog.req_num.cost()
print 'Memory size:', prog.allocated_mem
# finalize the memory
prog.finalize_memory()
return prog
def run_arithmetic(args, options, param=-1, merge_opens=True, \
reallocate=True, debug=False):
from Compiler.program import Program
from Compiler.config import *
from Compiler.exceptions import *
import instructions, instructions_base, types, comparison, library
import interface
from interface import ASTParser as ASTParser
import inspect
import copy
interface.mpc_type = interface.SPDZ
_interface = [t[1] for t in inspect.getmembers(interface, inspect.isclass)]
for op in _interface:
VARS[op.__name__] = op
""" Compile a file and output a Program object.
If merge_opens is set to True, will attempt to merge any parallelisable open
instructions. """
prog = Program(args, options, param)
instructions.program = prog
instructions_base.program = prog
types.program = prog
comparison.program = prog
prog.DEBUG = debug
VARS['program'] = prog
comparison.set_variant(options)
print 'Compiling file', prog.infile
if instructions_base.Instruction.count != 0:
print 'instructions count', instructions_base.Instruction.count
instructions_base.Instruction.count = 0
prog.FIRST_PASS = False
prog.reset_values()
# make compiler modules directly accessible
sys.path.insert(0, 'Compiler')
# create the tapes
print 'Compiling file', prog.infile
party = options.party
a = ASTParser(prog.infile, party, debug=True)
vectorized_calls, local_program = a.parse(options.split)
if local_program:
local_file = open(os.path.join(options.filename, "local.py"), "w")
local_file.write(local_program)
local_file.close()
a.execute(VARS)
# optimize the tapes
for tape in prog.tapes:
tape.optimize(options)
if prog.main_thread_running:
prog.update_req(prog.curr_tape)
print 'Program requires:', repr(prog.req_num)
print 'Memory size:', prog.allocated_mem
print 'Program requires {0} rounds of communication in total.'.format(
prog.rounds)
print 'Program requires {0} invocations in total.'.format(prog.invocations)
print 'Matmul calls: {0}'.format(vectorized_calls)
for k in vectorized_calls.keys():
prog.req_num[k] = vectorized_calls[k]
num_vectorized_triples, num_vectorized_bits = sub_vectorized_triples(
vectorized_calls, prog.req_num)
print "Due to vectorized triples, Reduced triple count by: {0}. Reduced bit count by: {1}.".format(
num_vectorized_triples, num_vectorized_bits)
#prog.req_num[('modp', 'triple')] -= num_vectorized_triples
#prog.req_num[('modp', 'bit')] -= num_vectorized_bits
# Don't want negative triples/bits
assert (prog.req_num[('modp', 'triple')] >= num_vectorized_triples)
assert (prog.req_num[('modp', 'bit')] >= num_vectorized_bits)
# finalize the memory
prog.finalize_memory()
# Write file to output
prog.write_bytes(options.outfile)
return prog
