163 lines
5.2 KiB
Python
163 lines
5.2 KiB
Python
# vim: ft=python
|
|
|
|
from Compiler import types
|
|
|
|
from Compiler.util import *
|
|
|
|
from Compiler.oram import OptimalORAM
|
|
|
|
from Compiler.library import for_range, do_while, time, if_, print_ln, crash, print_str
|
|
from Compiler.gs import OMatrix, OMatrixRow, OStack
|
|
|
|
|
|
class Matchmaker:
|
|
"""
|
|
Makes self.f_ranks and self.m_prefs as instances of OMatrix
|
|
We can call them p_cases (patient cases) and t_exps (therapist experience)
|
|
"""
|
|
|
|
def init_easy(self):
|
|
self.m_prefs = OMatrix(self.N, self.M, oram_type=self.oram_type,
|
|
int_type=self.int_type)
|
|
|
|
@for_range(self.N)
|
|
def f(i):
|
|
time()
|
|
types.cint(i).print_reg('mpre')
|
|
|
|
@for_range(self.M)
|
|
def f(j):
|
|
self.m_prefs[i][j] = (i + j) % self.N
|
|
|
|
self.f_ranks = OMatrix(self.N, oram_type=self.oram_type,
|
|
int_type=self.int_type)
|
|
|
|
@for_range(self.N)
|
|
def f(i):
|
|
time()
|
|
types.cint(i).print_reg('fran')
|
|
|
|
@for_range(self.M)
|
|
def f(j):
|
|
self.f_ranks[i][(j - i + self.N) % self.N] = j
|
|
|
|
def engage(self, man, woman, for_real):
|
|
self.wives.access(man, woman, for_real)
|
|
self.husbands.access(woman, man, for_real)
|
|
|
|
def dump(self, man, woman, for_real):
|
|
self.wives.delete(man, for_real)
|
|
self.husbands.delete(woman, for_real)
|
|
self.unengaged.append(man, for_real)
|
|
|
|
def propose(self, man, woman, for_real):
|
|
(fiance,), free = self.husbands.read(woman)
|
|
engaged = 1 - free
|
|
rank_man = self.f_ranks[woman][man]
|
|
(rank_fiance,), worst_fiance = self.f_ranks[woman].read(engaged*fiance)
|
|
leaving = self.int_type(rank_man) < self.int_type(rank_fiance)
|
|
if self.M < self.N:
|
|
leaving = 1 - (1 - leaving) * (1 - worst_fiance)
|
|
print_str('woman: %s, man: %s, fiance: %s, worst fiance: %s, ',
|
|
*(x.reveal() for x in (woman, man, fiance, worst_fiance)))
|
|
print_ln('rank man: %s, rank fiance: %s, engaged: %s, leaving: %s',
|
|
*(x.reveal() for x in
|
|
(rank_man, rank_fiance, engaged, leaving)))
|
|
self.dump(fiance, woman, engaged * leaving * for_real)
|
|
self.engage(man, woman, (1 - (engaged * (1 - leaving))) * for_real)
|
|
self.unengaged.append(man, engaged * (1 - leaving) * for_real)
|
|
|
|
def match(self, n_loops=None):
|
|
if n_loops is None or n_loops > self.N * self.M:
|
|
loop = do_while
|
|
init_rounds = self.N
|
|
else:
|
|
loop = for_range(n_loops)
|
|
init_rounds = n_loops / self.M
|
|
self.wives = \
|
|
self.oram_type(self.N, entry_size=log2(self.N),
|
|
init_rounds=0, value_type=self.basic_type)
|
|
self.husbands = \
|
|
self.oram_type(self.N, entry_size=log2(self.N),
|
|
init_rounds=0, value_type=self.basic_type)
|
|
propose = \
|
|
self.oram_type(self.N, entry_size=log2(self.N),
|
|
init_rounds=0, value_type=self.basic_type)
|
|
self.unengaged = OStack(self.N, oram_type=self.oram_type,
|
|
int_type=self.int_type)
|
|
|
|
@for_range(init_rounds)
|
|
def f(i):
|
|
self.unengaged.append(i)
|
|
rounds = types.MemValue(types.regint(0))
|
|
|
|
@loop
|
|
def f(i=None):
|
|
rounds.iadd(1)
|
|
time()
|
|
man = self.unengaged.pop()
|
|
pref = self.int_type(propose[man])
|
|
if self.M < self.N and n_loops is None:
|
|
@if_((pref == self.M).reveal())
|
|
def f():
|
|
print_ln('run out of acceptable women')
|
|
crash()
|
|
propose[man] = pref + 1
|
|
self.propose(man, self.m_prefs[man][pref], True)
|
|
print_ln('man: %s, pref: %s, left: %s',
|
|
*(x.reveal() for x in (man, pref, self.unengaged.size)))
|
|
return types.regint((self.unengaged.size > 0).reveal())
|
|
print_ln('%s rounds', rounds)
|
|
|
|
@for_range(init_rounds)
|
|
def f(i):
|
|
types.cint(i).print_reg('wife')
|
|
self.husbands[i].reveal().print_reg('husb')
|
|
|
|
def __init__(self, N, M=None, reverse=False, oram_type=OptimalORAM,
|
|
int_type=types.sint):
|
|
self.N = N
|
|
self.M = N if M is None else M
|
|
self.oram_type = oram_type
|
|
self.reverse = reverse
|
|
self.int_type = int_type
|
|
self.basic_type = int_type.basic_type
|
|
print('match', self.oram_type)
|
|
|
|
|
|
""" CONSTANTS """
|
|
|
|
PLAYERS = 3
|
|
MATCHING_SIZE = 2
|
|
|
|
|
|
""" Assembling lists """
|
|
|
|
p_shares = Matrix(rows=PLAYERS, columns=MATCHING_SIZE, value_type=sint)
|
|
|
|
# Fill data from players into the matrix
|
|
# The matrix is ordered as m[row:player][col:share]
|
|
@for_range(PLAYERS)
|
|
def _(i):
|
|
@for_range(MATCHING_SIZE)
|
|
def _(j):
|
|
p_shares[i][j] = sint.get_input_from(i)
|
|
|
|
@for_range(PLAYERS)
|
|
def _(i):
|
|
@for_range(MATCHING_SIZE)
|
|
def _(j):
|
|
print_ln('input from player %s: %s', i, p_shares[i][j].reveal())
|
|
|
|
# Add entire column together to reveal secret-shared input
|
|
|
|
@for_range(MATCHING_SIZE)
|
|
def _(i):
|
|
col = p_shares.get_column(i)
|
|
print_ln('res: %s', sum(col).reveal())
|
|
|
|
|
|
# mm = Matchmaker(50, oram_type=OptimalORAM)
|
|
# mm.init_easy()
|
|
# mm.match()
|