YAP 7.1.0
mpe.c
1/*************************************************************************
2* *
3* YAP Prolog *
4* *
5* Yap Prolog was developed at NCCUP - Universidade do Porto *
6* *
7* Copyright S. Konstantopoulos and Universidade do Porto 2002 *
8* *
9**************************************************************************
10* *
11* File: mpe.c *
12* Last rev: $Date: 2003-07-03 15:46:10 $ *
13* mods: *
14* comments: Interface to an MPE library *
15* *
16*************************************************************************/
17
18#ifndef lint
19// static char *rcsid = "$Header: /Users/vitor/Yap/yap-cvsbackup/library/mpi/mpe.c,v 1.6 2003-07-03 15:46:10 stasinos Exp $";
20#endif
21
22#include "Yap.h"
23
24/* Should we use MPI ? */
25#if defined(HAVE_MPI_H) && (defined(HAVE_LIBMPI) || defined(HAVE_LIBMPICH))
26 #define HAVE_MPI 1
27#else
28 #define HAVE_MPI 0
29#endif
30
31/* Should we use MPE ? */
32#if defined(HAVE_MPI_H) && HAVE_LIBMPE && HAVE_MPI
33 #define HAVE_MPE 1
34#else
35 #define HAVE_MPE 0
36#endif
37
38#if HAVE_MPE
39
40#if 0
41/* for AtomEof */
42#include "Heap.h"
43
44#include "yapio.h"
45
46#include <stdlib.h>
47#include <string.h>
48#endif
49
50#include "Yatom.h"
51#include <mpe.h>
52
53static Int p_init(void);
54static Int p_start(void);
55static Int p_close(void);
56static Int p_create_event(void);
57static Int p_create_state(void);
58static Int p_log(void);
59
60
61/*
62 * Auxiliary Data and Functions
63 */
64
65
66
67/*
68 * C Predicates
69 */
70
71
72static Int
73p_init() /* mpe_open */
74{
75 return (MPE_Init_log() == 0);
76}
77
78
79static Int
80p_start() /* mpe_start */
81{
82 return (MPE_Start_log() == 0);
83}
84
85
86static Int /* mpe_close(+FileName) */
87p_close()
88{
89 Term t_str = Deref(ARG1);
90 char *str;
91
92 /* The arg must be bound to an atom. */
93 if (IsVarTerm(t_str)) {
94 Yap_Error(INSTANTIATION_ERROR, t_str, "mpe_close");
95 return (FALSE);
96 } else if( !IsAtomTerm(t_str) ) {
97 Yap_Error(TYPE_ERROR_ATOM, t_str, "mpe_close");
98 return (FALSE);
99 } else {
100 str = RepAtom(AtomOfTerm(t_str))->StrOfAE;
101 }
102
103 return (MPE_Finish_log(str) == 0);
104}
105
106
107static Int /* mpe_create_event(?Event) */
108p_create_event()
109{
110 Int event_id;
111
112 event_id = MPE_Log_get_event_number();
113 return Yap_unify(ARG1, MkIntegerTerm(event_id));
114}
115
116static Int /* mpe_create_state(+Event,+Event,+Text,+Colour) */
117p_create_state()
118{
119 Term t_start = Deref(ARG1), t_end = Deref(ARG2),
120 t_descr = Deref(ARG3), t_colour = Deref(ARG4);
121 Int start_id, end_id;
122 char *descr, *colour;
123 int retv;
124
125 /* The first and second args must be bount to integer event IDs. */
126 if (IsVarTerm(t_start)) {
127 Yap_Error(INSTANTIATION_ERROR, t_start, "mpe_create_state");
128 return (FALSE);
129 } else if( !IsIntegerTerm(t_start) ) {
130 Yap_Error(TYPE_ERROR_INTEGER, t_start, "mpe_create_state");
131 return (FALSE);
132 } else {
133 start_id = IntOfTerm(t_start);
134 }
135 if (IsVarTerm(t_end)) {
136 Yap_Error(INSTANTIATION_ERROR, t_end, "mpe_create_state");
137 return (FALSE);
138 } else if( !IsIntegerTerm(t_end) ) {
139 Yap_Error(TYPE_ERROR_INTEGER, t_end, "mpe_create_state");
140 return (FALSE);
141 } else {
142 end_id = IntOfTerm(t_end);
143 }
144
145 /* The third and fourth args must be bound to atoms. */
146 if (IsVarTerm(t_descr)) {
147 Yap_Error(INSTANTIATION_ERROR, t_descr, "mpe_create_state");
148 return (FALSE);
149 } else if( !IsAtomTerm(t_descr) ) {
150 Yap_Error(TYPE_ERROR_ATOM, t_descr, "mpe_create_state");
151 return (FALSE);
152 } else {
153 descr = RepAtom(AtomOfTerm(t_descr))->StrOfAE;
154 }
155 if (IsVarTerm(t_colour)) {
156 Yap_Error(INSTANTIATION_ERROR, t_colour, "mpe_create_state");
157 return (FALSE);
158 } else if( !IsAtomTerm(t_colour) ) {
159 Yap_Error(TYPE_ERROR_ATOM, t_colour, "mpe_create_state");
160 return (FALSE);
161 } else {
162 colour = RepAtom(AtomOfTerm(t_colour))->StrOfAE;
163 }
164
165 retv = MPE_Describe_state( (int)start_id, (int)end_id, descr, colour );
166
167 return (retv == 0);
168}
169
170
171static Int
172p_log() /* mpe_log(+EventType, +EventNum, +EventStr) */
173{
174 Term t_type = Deref(ARG1), t_num = Deref(ARG2), t_str = Deref(ARG3);
175 Int event_id, event;
176 char *descr;
177
178 /* The first arg must be bount to integer event type ID. */
179 if (IsVarTerm(t_type)) {
180 Yap_Error(INSTANTIATION_ERROR, t_type, "mpe_log");
181 return (FALSE);
182 } else if( !IsIntegerTerm(t_type) ) {
183 Yap_Error(TYPE_ERROR_INTEGER, t_type, "mpe_log");
184 return (FALSE);
185 } else {
186 event_id = IntOfTerm(t_type);
187 }
188
189 /* The second arg must be bount to integer event number. */
190 if (IsVarTerm(t_num)) {
191 Yap_Error(INSTANTIATION_ERROR, t_num, "mpe_log");
192 return (FALSE);
193 } else if( !IsIntegerTerm(t_num) ) {
194 Yap_Error(TYPE_ERROR_INTEGER, t_num, "mpe_log");
195 return (FALSE);
196 } else {
197 event = IntOfTerm(t_num);
198 }
199
200 /* The third arg must be bound to an atom. */
201 if (IsVarTerm(t_str)) {
202 Yap_Error(INSTANTIATION_ERROR, t_str, "mpe_log");
203 return (FALSE);
204 } else if( !IsAtomTerm(t_str) ) {
205 Yap_Error(TYPE_ERROR_ATOM, t_str, "mpe_log");
206 return (FALSE);
207 } else {
208 descr = RepAtom(AtomOfTerm(t_str))->StrOfAE;
209 }
210
211 return ( MPE_Log_event((int)event_id, (int)event, descr) == 0 );
212}
213
214
215/*
216 * Init
217 */
218
219
220void
221Yap_InitMPE(void)
222{
223 Yap_InitCPred( "mpe_open", 0, p_init, SafePredFlag );
224 Yap_InitCPred( "mpe_start", 0, p_start, SafePredFlag );
225 Yap_InitCPred( "mpe_close", 1, p_close, SafePredFlag );
226 Yap_InitCPred( "mpe_create_event", 1, p_create_event, SafePredFlag );
227 Yap_InitCPred( "mpe_create_state", 4, p_create_state, SafePredFlag );
228 Yap_InitCPred( "mpe_log", 3, p_log, SafePredFlag );
229}
230
231#endif /* HAVE_MPE */
Yap.h
Main definitions.