/**
 * 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)).