modelverse/kernel/modelverse_kernel/compiled.py

from modelverse_kernel.primitives import PrimitiveFinished
import modelverse_jit.runtime as jit_runtime 
import time

def reverseKeyLookupMulti(a, b, **remainder):
    #PROFILE start = time.time()
    edges, b_val, result = yield [("RO", [a]), ("RV", [b]), ("CN", [])]
    expanded_edges = yield [("RE", [i]) for i in edges]
    values = yield [("RV", [i[1]]) for i in expanded_edges]

    # Keep results in a local Python set, as we want to bundle as many requests as possible
    todo = set()
    for i, edge in enumerate(values):
        if b_val == edge:
            todo.add(i)

    outgoings = yield [("RO", [edges[i]]) for i in todo]
    values = yield [("RE", [outgoing[0]]) for outgoing in outgoings]
    edges = yield [("CE", [result, result]) for value in values]
    yield [("CE", [edge, value[1]]) for edge, value in zip(edges, values)]

    #PROFILE print("[COMPILED]reverseKeyLookupMulti : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(result)

def reverseKeyLookup(a, b, **remainder):
    #PROFILE start = time.time()
    edges_out, edges_in = yield [("RO", [a]), ("RI", [b])]
    options = set(edges_out) & set(edges_in)
    if options:
        # Select one option randomly
        edge = options.pop()
        out_edges, = yield [("RO", [edge])]
        # Select one option randomly
        out_edge = out_edges.pop()
        e, = yield [("RE", [out_edge])]
        result = e[1]
    else:
        result, = yield [("CNV", ["(unknown: %s)" % b])]
    #PROFILE print("[COMPILED]reverseKeyLookup : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(result)

def instantiated_name(a, b, **remainder):
    #PROFILE start = time.time()
    name_value, = yield [("RV", [b])]
    if name_value == "":
        b, = yield [("CNV", ["__" + str(a)])]
    #PROFILE print("[COMPILED]instantiated_name : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(b)

def set_merge(a, b, **remainder):
    #PROFILE start = time.time()
    keys, =         yield [("RDK", [b])]
    edges =         yield [("CE", [a, a]) for key in keys]
    _ =             yield [("CE", [edge, key]) for edge, key in zip(edges, keys)]
    #PROFILE print("[COMPILED]set_merge : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(a)

def has_value(a, **remainder):
    #PROFILE start = time.time()
    v, = yield [("RV", [a])]
    if v is None:
        result, = yield [("CNV", [False])]
    else:
        result, = yield [("CNV", [True])]
    #PROFILE print("[COMPILED]has_value : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(result)

def make_reverse_dictionary(a, **remainder):
    #PROFILE start = time.time()
    reverse, = yield [("CN", [])]
    key_nodes, = yield [("RDK", [a])]
    values = yield [("RDN", [a, i]) for i in key_nodes]
    yield [("CD", [reverse, str(v), k]) for k, v in zip(key_nodes, values)]
    #PROFILE print("[COMPILED]make_reverse_dictionary : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(reverse)

def dict_eq(a, b, **remainder):
    #PROFILE start = time.time()
    key_nodes, = yield [("RDK", [a])]
    key_values = yield [("RV", [i]) for i in key_nodes]
    values = yield [("RD", [a, i]) for i in key_values]
    values = yield [("RV", [i]) for i in values]
    a_dict = dict(zip(key_values, values))

    key_nodes, = yield [("RDK", [b])]
    key_values = yield [("RV", [i]) for i in key_nodes]
    values = yield [("RD", [b, i]) for i in key_values]
    values = yield [("RV", [i]) for i in values]
    b_dict = dict(zip(key_values, values))

    result, = yield [("CNV", [a_dict == b_dict])]
    #PROFILE print("[COMPILED]dict_eq : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(result)

def string_substr(a, b, c, **remainder):
    #PROFILE start = time.time()
    a_val, b_val, c_val = yield [("RV", [a]),
                                 ("RV", [b]),
                                 ("RV", [c])]
    try:
        new_value = a_val[b_val:c_val]
    except:
        new_value = ""
    
    result, = yield [("CNV", [new_value])]
    #PROFILE print("[COMPILED]string_substr : %s : %s" % (time.time() - start, time.time() - start))
    raise PrimitiveFinished(result)

def integer_gt(a, b, **remainder):
    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
    result, = yield [("CNV", [a_value > b_value])]
    raise PrimitiveFinished(result)

def integer_neg(a, **remainder):
    a_value, =          yield [("RV", [a])]
    result, = yield [("CNV", [-a_value])]
    raise PrimitiveFinished(result)

def float_gt(a, b, **remainder):
    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
    result, = yield [("CNV", [a_value > b_value])]
    raise PrimitiveFinished(result)

def float_neg(a, **remainder):
    a_value, =          yield [("RV", [a])]
    result, = yield [("CNV", [-a_value])]
    raise PrimitiveFinished(result)

def value_neq(a, b, **remainder):
    a_value, b_value =  yield [("RV", [a]), ("RV", [b])]
    result, = yield [("CNV", [a_value != b_value])]
    raise PrimitiveFinished(result)

def element_neq(a, b, **remainder):
    result, = yield [("CNV", [a != b])]
    raise PrimitiveFinished(result)

def list_append(a, b, **remainder):
    a_outgoing, = yield [("RO", [a])]
    _ = yield [("CD", [a, len(a_outgoing), b])]
    raise PrimitiveFinished(a)

def list_read(a, b, **remainder):
    b_value, = yield [("RV", [b])]
    result, = yield [("RD", [a, b_value])]
    if result is None:
        raise Exception("List read out of bounds: %s" % b_value)
    raise PrimitiveFinished(result)

def list_len(a, **remainder):
    outgoings, = yield [("RO", [a])]
    result, = yield [("CNV", [len(outgoings)])]
    raise PrimitiveFinished(result)

def dict_add(a, b, c, **remainder):
    new_edge, = yield [("CE", [a, c])]
    yield [("CE", [new_edge, b])]
    raise PrimitiveFinished(a)

def dict_len(a, **remainder):
    outgoings, = yield [("RO", [a])]
    result, = yield [("CNV", [len(outgoings)])]
    raise PrimitiveFinished(result)

def set_add(a, b, **remainder):
    v, =        yield [("RV", [b])]
    is_in, =    yield [("RD", [a, v])]
    if not is_in:
        _, =    yield [("CD", [a, v, a])]
    raise PrimitiveFinished(a)

def set_add_node(a, b, **remainder):
    is_in, =    yield [("RDN", [a, b])]
    if not is_in:
        edge, = yield [("CE", [a, a])]
        _, =    yield [("CE", [edge, b])]
    raise PrimitiveFinished(a)

def set_pop(a, **remainder):
    outgoing, = yield [("RO", [a])]
    if outgoing:
        outgoing = outgoing[0]
        new_outgoing, = yield [("RO", [outgoing])]
        new_outgoing = new_outgoing[0]
        edge, _ = yield [("RE", [new_outgoing]), ("DE", [outgoing])]
        raise PrimitiveFinished(edge[1])
    else:
        raise Exception("POP from empty set")
        print("Pop from empty set!")
        raise PrimitiveFinished(remainder["root"])

def set_create(**remainder):
    result, = yield [("CN", [])]
    raise PrimitiveFinished(result)

def list_create(**remainder):
    result, = yield [("CN", [])]
    raise PrimitiveFinished(result)

def dict_create(**remainder):
    result, = yield [("CN", [])]
    raise PrimitiveFinished(result)

def create_tuple(a, b, **remainder):
    result, = yield [("CN", [])]
    _, _ =    yield [("CD", [result, 0, a]),
                     ("CD", [result, 1, b]),
                    ]
    raise PrimitiveFinished(result)