Prolog "brainfog"

         
/**
* Warranty & Liability
* To the extent permitted by applicable law and unless explicitly
* otherwise agreed upon, XLOG Technologies AG makes no warranties
* regarding the provided information. XLOG Technologies AG assumes
* no liability that any problems might be solved with the information
* provided by XLOG Technologies AG.
*
* Rights & License
* All industrial property rights regarding the information - copyright
* and patent rights in particular - are the sole property of XLOG
* Technologies AG. If the company was not the originator of some
* excerpts, XLOG Technologies AG has at least obtained the right to
* reproduce, change and translate the information.
*
* Reproduction is restricted to the whole unaltered document. Reproduction
* of the information is only allowed for non-commercial uses. Selling,
* giving away or letting of the execution of the library is prohibited.
* The library can be distributed as part of your applications and libraries
* for execution provided this comment remains unchanged.
*
* Restrictions
* Only to be distributed with programs that add significant and primary
* functionality to the library. Not to be distributed with additional
* software intended to replace any components of the library.
*
* Trademarks
* Jekejeke is a registered trademark of XLOG Technologies AG.
*/
/**
* See also:
* The Elements of Computing Systems
* Nisan, N. and Schocken, S. - June 15, 2021, MIT Press
* https://mitpress.mit.edu/9780262539807/the-elements-of-computing-systems/
*/
:- ensure_loaded(library(lists)).
:- ensure_loaded(library(hiord)).
:- ensure_loaded(library(misc/intercom)).
/***************************************************************/
/* CPU Backend */
/***************************************************************/
/**
* execute(G):
* execute(G, O):
* The predicate succeeds. As a side effect it runs G on a
* CPU backend for π-WAM. The binary predicate allows
* specifying hack options O.
*/
% execute(+Goal)
execute(GOAL) :-
execute(GOAL, []).
% execute(+Goal, +List)
execute(GOAL, OPTS) :-
sys_hack_opts(OPTS, v(1,[],[]), v(NUM,_,_)),
sys_trans_body(GOAL, nothing, MARK, 1, CONT, []),
catch((cpu_comp_prep(MARK, CONT, NUM, COMP), throw(sys_ball(COMP))),
sys_ball(COMP2), cpu_comp_run(COMP2)).
% cpu_comp_prep(+Option, +List, +Integer, -Object)
cpu_comp_prep(MARK, CONT, NUM, COMP) :-
sys_comp_comp(MARK, CONT, NUM, CODE, OFFSETS, CHANS, STATE),
maplist(sys_pack_instr, CODE, CODE2),
% write('CODE2='), write(CODE2), write(', LEN='), write(LEN), nl,
cpu_comp_create(CODE2, OFFSETS, CHANS, STATE, COMP).
% cpu_comp_create(+List, +List, +List, +List, -Object)
cpu_comp_create(CODE, OFFSETS, CHANS, STATE, COMP) :-
cpu_buf_new(CODE, BUF),
cpu_buf_new(OFFSETS, BUF2),
cpu_comm_new(CHANS, BUF3),
cpu_buf_new(STATE, BUF4),
cpu_comp_new(BUF, BUF2, BUF3, BUF4, COMP).
% cpu_comp_run(+Object)
cpu_comp_run(COMP) :-
cpu_comp_count(COMP, COUNT),
length(IDXS, COUNT),
sys_number_list(IDXS, 0, 1),
maplist(cpu_group_submit(COMP), IDXS, GROUPS),
maplist(cpu_group_done, GROUPS).
% cpu_group_submit(+Object, +Integer, -Object)
cpu_group_submit(COMP, IDX, GROUP) :-
cpu_group_new(COMP, GROUP),
cpu_group_start(GROUP, IDX).
% cpu_group_done(+Object)
cpu_group_done(GROUP) :-
cpu_group_join(GROUP, PROM),
'$YIELD'(PROM),
cpu_group_free(GROUP).
/***************************************************************/
/* GPU Backend */
/***************************************************************/
/**
* expedite(G):
* expedite(G, O):
* The predicate succeeds. As a side effect it runs G on a
* GPU backend for π-WAM. The binary predicate allows
* specifying hack options O.
*/
% expedite(+Goal)
expedite(GOAL) :-
expedite(GOAL, []).
% expedite(+Goal, +List)
expedite(GOAL, OPTS) :-
sys_hack_opts(OPTS, v(1,[],[]), v(NUM,_,_)),
sys_trans_body(GOAL, nothing, MARK, 1, CONT, []),
catch((gpu_comp_prep(MARK, CONT, NUM, COMP), throw(sys_ball(COMP))),
sys_ball(COMP2), gpu_comp_run(COMP2)).
% gpu_comp_prep(+Option, +List, +Integer, -Pair)
gpu_comp_prep(MARK, CONT, NUM, COMP) :-
sys_comp_comp(MARK, CONT, NUM, CODE, OFFSETS, CHANS, STATE),
maplist(sys_pack_instr, CODE, CODE2),
% write('CODE2='), write(CODE2), write(', LEN='), write(LEN), nl,
gpu_comp_create(CODE2, OFFSETS, CHANS, STATE, COMP).
% gpu_comp_create(+List, +List, +List, +List, -Pair)
gpu_comp_create(CODE, OFFSETS, CHANS, STATE, DEV-JOB) :-
os_obj_new(MAP),
gpu_device_new(MAP, PROM),
'$YIELD'(PROM),
os_obj_current(MAP, 'device', DEV),
gpu_buf_new(CODE, BUF),
gpu_buf_new(OFFSETS, BUF2),
gpu_comm_new(CHANS, BUF3),
gpu_buf_new(STATE, BUF4),
gpu_job_new(DEV, BUF, BUF2, BUF3, BUF4, JOB).
% gpu_comp_run(+Pair)
gpu_comp_run(DEV-JOB) :-
gpu_job_start(DEV, JOB),
gpu_device_join(DEV, PROM),
'$YIELD'(PROM),
gpu_device_free(DEV).
/***************************************************************/
/* Allocator */
/***************************************************************/
% sys_comp_comp(+Goal, +Integer, -List, -List, -List, -List)
sys_comp_comp(MARK, CONT, NUM, CODE, OFFSETS, CHANS, STATE) :-
sys_comp_prog(MARK, CONT, CODE, CHANS, LEN),
length(OFFSETS, NUM),
LEN3 is 3+LEN,
sys_number_list(OFFSETS, 3, LEN3),
LEN2 is LEN3*NUM,
length(STATE, LEN2),
sys_number_list(STATE, 0, 0).
% sys_comp_prog(+Option, +Goal, -List, -List, -Integer)
sys_comp_prog(MARK, CONT, CODE, CHANS, LEN) :-
sys_comp_body(MARK, ALLOC, CONT, 0-CODE, _-[]),
sys_bufs_current(ALLOC, BUFS),
sys_close_list(BUFS),
term_variables(BUFS-CODE, LIST),
sys_number_list(LIST, 0, 1),
length(LIST, LEN),
sys_chans_current(ALLOC, CHANS),
sys_close_list(CHANS).
% sys_comp_body(+Option, +Triple, +List, -List, +List)
sys_comp_body(nothing, ALLOC, CONT) -->
sys_comp_cont(CONT, ALLOC).
sys_comp_body(just(LABEL), ALLOC, CONT) -->
sys_comp_cont(CONT, ALLOC),
sys_label(LABEL).
% sys_close_list(+List)
sys_close_list([]) :- !.
sys_close_list([_|L]) :-
sys_close_list(L).
% sys_number_list(+List, +Integer, +Integer)
sys_number_list([], _, _).
sys_number_list([X|L], X, D) :-
Y is X+D,
sys_number_list(L, Y, D).
/***************************************************************/
/* Compiler */
/***************************************************************/
% sys_comp_cont(+List, +Triple, -List, +List)
sys_comp_cont([], _) --> !.
sys_comp_cont([GOAL|CONT], ALLOC) --> !,
sys_comp_goal(GOAL, ALLOC, CONT).
% sys_comp_goal(+Goal, +Triple, +List, -List, +List)
sys_comp_goal(VAR, _, _) --> {var(VAR),
throw(error(instantiation_error,_))}.
sys_comp_goal(gid(TERM), ALLOC, CONT) --> !,
sys_instr((get,mov,-3)),
sys_comp_is(TERM, ALLOC, CONT).
sys_comp_goal(TERM is EXPR, ALLOC, CONT) --> !,
{sys_regs_current(ALLOC, REGS)},
sys_comp_arith(EXPR, REGS),
sys_comp_is(TERM, ALLOC, CONT).
sys_comp_goal('$STORE'(LIST, MORE), ALLOC, CONT) --> !,
sys_comp_store(LIST, MORE, ALLOC, CONT).
sys_comp_goal(send(CHAN, LIST), ALLOC, CONT) --> !,
sys_comp_send(CHAN, LIST, ALLOC, CONT).
sys_comp_goal(recv(CHAN, LIST), ALLOC, CONT) --> !,
sys_comp_recv(CHAN, LIST, ALLOC, CONT).
sys_comp_goal(EXPR =:= EXPR2, ALLOC, CONT) --> !,
sys_comp_cond(EXPR, EXPR2, eq, ALLOC, CONT).
sys_comp_goal(EXPR =\= EXPR2, ALLOC, CONT) --> !,
sys_comp_cond(EXPR, EXPR2, nq, ALLOC, CONT).
sys_comp_goal(EXPR < EXPR2, ALLOC, CONT) --> !,
sys_comp_cond(EXPR, EXPR2, ls, ALLOC, CONT).
sys_comp_goal(EXPR > EXPR2, ALLOC, CONT) --> !,
sys_comp_cond(EXPR, EXPR2, gr, ALLOC, CONT).
sys_comp_goal(EXPR =< EXPR2, ALLOC, CONT) --> !,
sys_comp_cond(EXPR, EXPR2, lq, ALLOC, CONT).
sys_comp_goal(EXPR >= EXPR2, ALLOC, CONT) --> !,
sys_comp_cond(EXPR, EXPR2, gq, ALLOC, CONT).
sys_comp_goal(between(TERM, TERM2, VAR), ALLOC, CONT) --> !,
sys_comp_build(TERM, mov),
sys_instr((set,mov,VAR)),
sys_label(LOOP),
sys_comp_build(TERM2, mov),
sys_instr((get,gq,VAR)),
sys_instr((brz,mov,THERE)),
sys_comp_cont(CONT, ALLOC),
sys_instr((get,mov,VAR)),
sys_instr((cst,add,1)),
sys_instr((set,mov,VAR)),
sys_instr((bra,mov,LOOP)),
sys_label(THERE).
sys_comp_goal(true, ALLOC, CONT) --> !,
sys_comp_cont(CONT, ALLOC).
sys_comp_goal(fail, ALLOC, CONT) --> !,
sys_instr((bra,mov,THERE)),
sys_comp_cont(CONT, ALLOC),
sys_label(THERE).
sys_comp_goal(repeat, ALLOC, CONT) --> !,
sys_label(LOOP),
sys_comp_cont(CONT, ALLOC),
sys_instr((bra,mov,LOOP)).
sys_comp_goal('$MARK'(LABEL), ALLOC, CONT) --> !,
sys_comp_cont(CONT, ALLOC),
sys_label(LABEL).
sys_comp_goal('$CUT'(LABEL), ALLOC, CONT) --> !,
sys_comp_cont(CONT, ALLOC),
sys_instr((bra,mov,LABEL)).
sys_comp_goal('$ALT'(LIST), ALLOC, CONT) --> !,
{sys_regs_current(ALLOC, [TEMP|REGS])},
sys_comp_disj(LIST, ALLOC, ENTRY, EXIT),
sys_instr((bra,mov,EXIT)),
sys_label(ENTRY),
sys_instr((set,mov,TEMP)),
{sys_regs_set(ALLOC, REGS, ALLOC2)},
sys_comp_cont(CONT, ALLOC2),
sys_instr((jma,mov,TEMP)),
sys_label(EXIT).
sys_comp_goal('$JSR'(ENTRY), ALLOC, CONT) --> !,
sys_instr((bra,mov,ENTRY)),
sys_comp_cont(CONT, ALLOC).
sys_comp_goal('$SEQ'(nothing, LIST), ALLOC, CONT) --> !,
{append(LIST, CONT, CONT2)},
sys_comp_cont(CONT2, ALLOC).
sys_comp_goal('$SEQ'(just(LABEL), LIST), ALLOC, CONT) --> !,
{append(LIST, CONT, CONT2)},
sys_comp_cont(CONT2, ALLOC),
sys_label(LABEL).
sys_comp_goal(TERM, _, _) --> {functor(TERM, FUN, ARITY),
throw(error(existence_error(procedure,FUN/ARITY),_))}.
% sys_comp_cond(+Expr, +Expr, +Atom, +Triple, +List, -List, +List)
sys_comp_cond(EXPR, VAR, COND, ALLOC, CONT) --> {var(VAR)}, !,
{sys_regs_current(ALLOC, REGS)},
sys_comp_arith(EXPR, REGS),
sys_comp_build(VAR, COND),
sys_instr((brz,mov,THERE)),
sys_comp_cont(CONT, ALLOC),
sys_label(THERE).
sys_comp_cond(EXPR, CONST, COND, ALLOC, CONT) --> {integer(CONST)}, !,
{sys_regs_current(ALLOC, REGS)},
sys_comp_arith(EXPR, REGS),
sys_comp_build(CONST, COND),
sys_instr((brz,mov,THERE)),
sys_comp_cont(CONT, ALLOC),
sys_label(THERE).
sys_comp_cond(EXPR, EXPR2, COND, ALLOC, CONT) -->
{sys_regs_current(ALLOC, REGS)},
sys_comp_arith(EXPR2, REGS),
sys_instr((set,mov,TEMP)),
sys_comp_arith(EXPR, REGS),
sys_instr((get,COND,TEMP)),
sys_instr((brz,mov,THERE)),
sys_comp_cont(CONT, ALLOC),
sys_label(THERE).
% sys_comp_disj(+List, +Triple, +List, +Integer, +Integer, -List, +List)
sys_comp_disj(['$SEQ'(MARK,CONT)|LIST], ALLOC, ENTRY, EXIT) -->
sys_comp_alter(MARK, CONT, ALLOC, ENTRY, EXIT),
sys_comp_disj(LIST, ALLOC, ENTRY, EXIT).
sys_comp_disj([], _, _, _) --> [].
% sys_comp_alter(+Option, +List, +Triple, +Integer, +Integer, -List, +List)
sys_comp_alter(nothing, CONT, ALLOC, ENTRY, _) -->
{append(CONT, ['$JSR'(ENTRY)], CONT2)},
sys_comp_cont(CONT2, ALLOC).
sys_comp_alter(just(EXIT), CONT, ALLOC, ENTRY, EXIT) -->
{append(CONT, ['$JSR'(ENTRY)], CONT2)},
sys_comp_cont(CONT2, ALLOC).
/***************************************************************/
/* Channels */
/***************************************************************/
% sys_comp_recv(+Integer, +List, +Triple, +List, -List, +List)
sys_comp_recv(CHAN, LIST, ALLOC, CONT) --> {length(LIST, LEN),
sys_bufs_current(ALLOC, [TEMP|BUFS])},
sys_instr((cst,mov,LEN)),
sys_instr((set,mov,TEMP)),
sys_label(LOOP),
sys_comp_chan(CHAN, in, ALLOC),
sys_instr((brz,mov,LOOP)),
sys_comp_store([LEN|LIST], [TEMP|BUFS], ALLOC, CONT).
% sys_comp_store(+List, +List, +Triple, +List, -List, +List)
sys_comp_store([], _, ALLOC, CONT) -->
sys_comp_cont(CONT, ALLOC).
sys_comp_store([TERM|LIST], [TEMP|MORE], ALLOC, CONT) -->
sys_comp_build(TEMP, mov),
sys_comp_is(TERM, ALLOC, ['$STORE'(LIST, MORE)|CONT]).
% sys_comp_send(+Term, +List, +Triple, +List, -List, +List)
sys_comp_send(CHAN, LIST, ALLOC, CONT) --> {length(LIST, LEN),
sys_bufs_current(ALLOC, [TEMP|BUFS])},
sys_instr((cst,mov,LEN)),
sys_instr((set,mov,TEMP)),
sys_comp_load(LIST, BUFS),
sys_label(LOOP),
sys_comp_chan(CHAN, out, ALLOC),
sys_instr((brz,mov,LOOP)),
sys_comp_cont(CONT, ALLOC).
% sys_comp_load(+List, +List, -List, +List)
sys_comp_load([], _) --> [].
sys_comp_load([TERM|LIST], [TEMP|MORE]) -->
sys_comp_build(TERM, mov),
sys_instr((set,mov,TEMP)),
sys_comp_load(LIST, MORE).
% sys_comp_chan(+Term, +Atom, +Triple, -List, +List)
sys_comp_chan(VAR, _, _) --> {var(VAR),
throw(error(instantiation_error,_))}.
sys_comp_chan(CHAN, CMD, _) --> {integer(CHAN)}, !,
sys_instr((CMD,mov,CHAN)).
sys_comp_chan(CHAN, CMD, ALLOC) --> {atomic(CHAN)}, !,
{sys_chans_current(ALLOC, CHANS),
once(nth0(IDX, CHANS, CHAN))},
sys_instr((CMD,mov,IDX)).
sys_comp_chan(TERM, _, _) -->
{throw(error(type_error(channel,TERM),_))}.
/***************************************************************/
/* Arithmetic */
/***************************************************************/
% sys_comp_arith(+Expr, +List, -List, +List)
sys_comp_arith(VAR, _) --> {var(VAR)}, !,
sys_comp_build(VAR, mov).
sys_comp_arith(CONST, _) --> {integer(CONST)}, !,
sys_comp_build(CONST, mov).
sys_comp_arith(-EXPR, REGS) --> !,
sys_comp_unary(EXPR, neg, REGS).
sys_comp_arith(EXPR+EXPR2, REGS) --> !,
sys_comp_binary(EXPR, EXPR2, add, REGS).
sys_comp_arith(EXPR-EXPR2, REGS) --> !,
sys_comp_binary(EXPR, EXPR2, sub, REGS).
sys_comp_arith(EXPR*EXPR2, REGS) --> !,
sys_comp_binary(EXPR, EXPR2, mul, REGS).
sys_comp_arith(EXPR//EXPR2, REGS) --> !,
sys_comp_binary(EXPR, EXPR2, zdiv, REGS).
sys_comp_arith(EXPR rem EXPR2, REGS) --> !,
sys_comp_binary(EXPR, EXPR2, rem, REGS).
sys_comp_arith(min(EXPR,EXPR2), REGS) --> !,
sys_comp_binary(EXPR, EXPR2, min, REGS).
sys_comp_arith(max(EXPR,EXPR2), REGS) --> !,
sys_comp_binary(EXPR, EXPR2, max, REGS).
sys_comp_arith(EXPR, _) --> {functor(EXPR,FUN,ARITY),
throw(error(type_error(evaluable,FUN/ARITY),_))}.
% sys_comp_unary(+Expr, +Atom, +List, -List, +List)
sys_comp_unary(VAR, FUN, _) --> {var(VAR)}, !,
sys_comp_build(VAR, FUN).
sys_comp_unary(CONST, FUN, _) --> {integer(CONST)}, !,
sys_comp_build(CONST, FUN).
sys_comp_unary(EXPR, FUN, [TEMP|REGS]) -->
sys_comp_arith(EXPR, REGS),
sys_instr((set,mov,TEMP)),
sys_instr((get,FUN,TEMP)).
% sys_comp_binary(+Expr, +Expr, +Atom, +List, -List, +List)
sys_comp_binary(EXPR, VAR, FUN, REGS) --> {var(VAR)}, !,
sys_comp_arith(EXPR, REGS),
sys_comp_build(VAR, FUN).
sys_comp_binary(EXPR, CONST, FUN, REGS) --> {integer(CONST)}, !,
sys_comp_arith(EXPR, REGS),
sys_comp_build(CONST, FUN).
sys_comp_binary(EXPR, EXPR2, FUN, [TEMP|REGS]) -->
sys_comp_arith(EXPR2, REGS),
sys_instr((set,mov,TEMP)),
sys_comp_arith(EXPR, REGS),
sys_instr((get,FUN,TEMP)).
/***************************************************************/
/* Matcher */
/***************************************************************/
% sys_comp_build(+Term, +Atom, -List, +List)
sys_comp_build(VAR, FUN) --> {var(VAR)}, !,
sys_instr((get,FUN,VAR)).
sys_comp_build(CONST, FUN) --> {integer(CONST),
-0x00800000 =< CONST, CONST =< 0x007FFFFF}, !,
sys_instr((cst,FUN,CONST)).
sys_comp_build(CONST, FUN) --> {integer(CONST),
-0x80000000 =< CONST, CONST =< 0x7FFFFFFF}, !,
sys_instr((ext,FUN,0)),
sys_instr(CONST).
sys_comp_build(_, _) -->
{throw(error(representation_error(int),_))}.
% sys_comp_is(+Term, +Triple, +List, -List, +List)
sys_comp_is(VAR, ALLOC, CONT) --> {var(VAR)}, !,
sys_instr((set,mov,VAR)),
sys_comp_cont(CONT, ALLOC).
sys_comp_is(CONST, ALLOC, CONT) --> {integer(CONST),
-0x00800000 =< CONST, CONST =< 0x007FFFFF}, !,
sys_instr((cst,eq,CONST)),
sys_instr((brz,mov,THERE)),
sys_comp_cont(CONT, ALLOC),
sys_label(THERE).
sys_comp_is(CONST, ALLOC, CONT) --> {integer(CONST),
-0x80000000 =< CONST, CONST =< 0x7FFFFFFF}, !,
sys_instr((ext,eq,0)),
sys_instr(CONST),
sys_instr((brz,mov,THERE)),
sys_comp_cont(CONT, ALLOC),
sys_label(THERE).
sys_comp_is(_, _, _) -->
{throw(error(representation_error(int),_))}.
/***************************************************************/
/* Assembly */
/***************************************************************/
% sys_label(-Integer, -List, +List)
sys_label(STEP, STEP-CODE, STEP-CODE).
% sys_instr(+Term, -List, +List)
sys_instr(INSTR, STEP-[INSTR|CODE], STEP2-CODE) :-
STEP2 is STEP+1.
% sys_regs_current(+Triple, -List).
sys_regs_current(a(REGS, _, _), REGS).
% sys_regs_set(+Triple, -List, -Triple).
sys_regs_set(a(_, BUFS, CHANS), REGS, a(REGS, BUFS, CHANS)).
% sys_bufs_current(+Triple, -List).
sys_bufs_current(a(_, BUFS, _), BUFS).
% sys_chans_current(+Triple, -List).
sys_chans_current(a(_, _, CHANS), CHANS).
/***************************************************************/
/* Encoder */
/***************************************************************/
% sys_pack_mode(+Atom, -Integer)
sys_pack_mode(cst, 0).
sys_pack_mode(get, 1).
sys_pack_mode(ext, 2).
sys_pack_mode(out, 3).
sys_pack_mode(in, 4).
sys_pack_mode(set, 5).
sys_pack_mode(bra, 6).
sys_pack_mode(brz, 7).
sys_pack_mode(jma, 8).
sys_pack_mode(jmz, 9).
% sys_pack_fun(+Atom, -Integer)
sys_pack_fun(mov, 0).
sys_pack_fun(neg, 1).
sys_pack_fun(add, 2).
sys_pack_fun(sub, 3).
sys_pack_fun(mul, 4).
sys_pack_fun(zdiv, 5).
sys_pack_fun(rem, 6).
sys_pack_fun(min, 7).
sys_pack_fun(max, 8).
sys_pack_fun(eq, 9).
sys_pack_fun(nq, 10).
sys_pack_fun(ls, 11).
sys_pack_fun(gr, 12).
sys_pack_fun(lq, 13).
sys_pack_fun(gq, 14).
% sys_pack_instr(+Term, -Integer)
sys_pack_instr(CONST, CONST) :- integer(CONST), !.
sys_pack_instr((MODE, FUN, OBJ), INSTR) :-
sys_pack_mode(MODE, VAL),
sys_pack_fun(FUN, VAL2),
INSTR is (VAL<<28) \/ (VAL2<<24) \/ (OBJ+0x00800000).
/***************************************************************/
/* Decode Hack Options */
/***************************************************************/
% sys_hack_opts(+List, +Triple, -Triple)
sys_hack_opts(V, _, _) :- var(V),
throw(error(instantiation_error,_)).
sys_hack_opts([X|L], I, O) :- !,
sys_hack_opt(X, I, H),
sys_hack_opts(L, H, O).
sys_hack_opts([], H, H) :- !.
sys_hack_opts(L, _, _) :-
throw(error(type_error(list,L),_)).
% sys_hack_opt(+Option, +Triple, -Triple)
sys_hack_opt(V, _, _) :- var(V),
throw(error(instantiation_error,_)).
sys_hack_opt(size(S), v(_,Y,Z), v(S,Y,Z)) :- !.
sys_hack_opt(data(D), v(X,_,Z), v(X,D,Z)) :- !.
sys_hack_opt(O, _, _) :-
throw(error(domain_error(hack_option,O),_)).
/****************************************************************/
/* Error Texts */
/****************************************************************/
% strings(+Atom, +Atom, -Atom)
:- multifile(strings/3).
strings('resource_error.shared_missing', de, 'Gemeinsamer Speicher fehlt').
strings('resource_error.shared_missing', '', 'Shared memory missing').
/*******************************************************************/
/* Foreign Predicates */
/*******************************************************************/
% cpu_comp_new(C, S, O, M):
% defined in foreign(misc/hacklib)
% cpu_comp_count(M, W):
% defined in foreign(misc/hacklib)
% cpu_group_new(M, G):
% defined in foreign(misc/hacklib)
% cpu_group_start(G, I):
% defined in foreign(misc/hacklib)
% cpu_group_join(G, P):
% defined in foreign(misc/hacklib)
% cpu_group_free(G):
% defined in foreign(misc/hacklib)
:- ensure_loaded(foreign(misc/hacklib)).
% gpu_device_new(M, P)
% defined in foreign(misc/cmdlib)
% gpu_device_join(D, P)
% defined in foreign(misc/cmdlib)
% gpu_device_free(D)
% defined in foreign(misc/cmdlib)
% gpu_job_new(D, C, O, T, S, W)
% defined in foreign(misc/cmdlib)
% gpu_job_start(D, W)
% defined in foreign(misc/cmdlib)
:- ensure_loaded(foreign(misc/cmdlib)).