← Back to branch summary

~ubuntu-branches/ubuntu/raring/simgrid/raring

« back to all changes in this revision

Viewing changes to src/simix/smx_smurf.c

  • Committer: Package Import Robot
  • Author(s): Lucas Nussbaum
  • Date: 2012-05-24 16:08:59 UTC
  • mfrom: (10.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20120524160859-vhdlh05p313l5662
Tags: 3.7-1
http://bugs.debian.org/656102
http://bugs.debian.org/640538
* New upstream release.
* Bump Standards-Version to 3.9.3. No changes needed.
* debian/rules: Enable the SMPI library in the package. Closes: #656102.
* Build with -O2 on ia64. Closes: #640538.
* Use dpkg-buildflags to generate CFLAGS and LDFLAGS. Enable hardening.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/simix/smx_smurf.c
1
 
#include "private.h"
 
1
#include "smx_private.h"
2
2
#include "xbt/fifo.h"
3
3
#include "xbt/xbt_os_thread.h"
4
4
 
5
5
XBT_LOG_NEW_DEFAULT_SUBCATEGORY(simix_smurf, simix,
6
6
                                "Logging specific to SIMIX (SMURF)");
7
7
 
8
 
/* FIXME: we may want to save the initialization of issuer... */
9
 
XBT_INLINE smx_req_t SIMIX_req_mine()
 
8
XBT_INLINE smx_simcall_t SIMIX_simcall_mine()
10
9
{
11
10
  smx_process_t issuer = SIMIX_process_self();
12
 
  return &issuer->request;
 
11
  return &issuer->simcall;
13
12
}
14
13
 
15
 
void SIMIX_request_push()
 
14
/**
 
15
 * \brief Makes the current process do a simcall to the kernel and yields
 
16
 * until completion. If the current thread is maestro, we don't yield and
 
17
 * execute the simcall directly.
 
18
 * \param self the current process
 
19
 */
 
20
void SIMIX_simcall_push(smx_process_t self)
16
21
{
17
 
  smx_process_t issuer = SIMIX_process_self();
18
 
 
19
 
  if (issuer != simix_global->maestro_process){
20
 
    issuer->request.issuer = issuer;
21
 
    XBT_DEBUG("Yield process '%s' on request of type %s (%d)", issuer->name,
22
 
        SIMIX_request_name(issuer->request.call), issuer->request.call);
23
 
    SIMIX_process_yield();
 
22
  if (self != simix_global->maestro_process) {
 
23
    XBT_DEBUG("Yield process '%s' on simcall %s (%d)", self->name,
 
24
              SIMIX_simcall_name(self->simcall.call), (int)self->simcall.call);
 
25
    SIMIX_process_yield(self);
24
26
  } else {
25
 
    SIMIX_request_pre(&issuer->request, 0);
26
 
  }
27
 
}
28
 
 
29
 
void SIMIX_request_answer(smx_req_t req)
30
 
{
31
 
  if (req->issuer != simix_global->maestro_process){
32
 
    XBT_DEBUG("Answer request %s (%d)", SIMIX_request_name(req->call), req->call);
33
 
    req->issuer->request.call = REQ_NO_REQ;
34
 
    xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, req->issuer);
35
 
  }
36
 
}
37
 
 
38
 
void SIMIX_request_pre(smx_req_t req, int value)
39
 
{
40
 
 
41
 
  switch (req->call) {
42
 
    case REQ_COMM_TEST:
43
 
      SIMIX_pre_comm_test(req);
44
 
      break;
45
 
 
46
 
    case REQ_COMM_TESTANY:
47
 
      SIMIX_pre_comm_testany(req, value);
48
 
      break;
49
 
 
50
 
    case REQ_COMM_WAIT:
51
 
      SIMIX_pre_comm_wait(req,
52
 
          req->comm_wait.comm,
53
 
          req->comm_wait.timeout,
 
27
    SIMIX_simcall_pre(&self->simcall, 0);
 
28
  }
 
29
}
 
30
 
 
31
void SIMIX_simcall_answer(smx_simcall_t simcall)
 
32
{
 
33
  if (simcall->issuer != simix_global->maestro_process){
 
34
    XBT_DEBUG("Answer simcall %s (%d) issued by %s (%p)", SIMIX_simcall_name(simcall->call), (int)simcall->call,
 
35
        simcall->issuer->name, simcall->issuer);
 
36
    simcall->issuer->simcall.call = SIMCALL_NONE;
 
37
/*    This check should be useless and slows everyone. Reactivate if you see something
 
38
 *    weird in process scheduling.
 
39
 */
 
40
/*    if(!xbt_dynar_member(simix_global->process_to_run, &(simcall->issuer))) */
 
41
    xbt_dynar_push_as(simix_global->process_to_run, smx_process_t, simcall->issuer);
 
42
/*    else DIE_IMPOSSIBLE; */
 
43
  }
 
44
}
 
45
 
 
46
void SIMIX_simcall_pre(smx_simcall_t simcall, int value)
 
47
{
 
48
  XBT_DEBUG("Handling simcall %p: %s", simcall, SIMIX_simcall_name(simcall->call));
 
49
 
 
50
  switch (simcall->call) {
 
51
    case SIMCALL_COMM_TEST:
 
52
      SIMIX_pre_comm_test(simcall);
 
53
      break;
 
54
 
 
55
    case SIMCALL_COMM_TESTANY:
 
56
      SIMIX_pre_comm_testany(simcall, value);
 
57
      break;
 
58
 
 
59
    case SIMCALL_COMM_WAIT:
 
60
      SIMIX_pre_comm_wait(simcall,
 
61
          simcall->comm_wait.comm,
 
62
          simcall->comm_wait.timeout,
54
63
          value);
55
64
      break;
56
65
 
57
 
    case REQ_COMM_WAITANY:
58
 
      SIMIX_pre_comm_waitany(req, value);
 
66
    case SIMCALL_COMM_WAITANY:
 
67
      SIMIX_pre_comm_waitany(simcall, value);
59
68
      break;
60
69
 
61
 
    case REQ_COMM_SEND:
 
70
    case SIMCALL_COMM_SEND:
62
71
    {
63
72
      smx_action_t comm = SIMIX_comm_isend(
64
 
          req->issuer,
65
 
          req->comm_send.rdv,
66
 
          req->comm_send.task_size,
67
 
          req->comm_send.rate,
68
 
          req->comm_send.src_buff,
69
 
          req->comm_send.src_buff_size,
70
 
          req->comm_send.match_fun,
71
 
          req->comm_send.data,
 
73
          simcall->issuer,
 
74
          simcall->comm_send.rdv,
 
75
          simcall->comm_send.task_size,
 
76
          simcall->comm_send.rate,
 
77
          simcall->comm_send.src_buff,
 
78
          simcall->comm_send.src_buff_size,
 
79
          simcall->comm_send.match_fun,
 
80
          NULL, /* no clean function since it's not detached */
 
81
          simcall->comm_send.data,
72
82
          0);
73
 
      SIMIX_pre_comm_wait(req, comm, req->comm_send.timeout, 0);
 
83
      SIMIX_pre_comm_wait(simcall, comm, simcall->comm_send.timeout, 0);
74
84
      break;
75
85
    }
76
86
 
77
 
    case REQ_COMM_ISEND:
78
 
      req->comm_isend.result = SIMIX_comm_isend(
79
 
          req->issuer,
80
 
          req->comm_isend.rdv,
81
 
          req->comm_isend.task_size,
82
 
          req->comm_isend.rate,
83
 
          req->comm_isend.src_buff,
84
 
          req->comm_isend.src_buff_size,
85
 
          req->comm_isend.match_fun,
86
 
          req->comm_isend.data,
87
 
          req->comm_isend.detached);
88
 
      SIMIX_request_answer(req);
 
87
    case SIMCALL_COMM_ISEND:
 
88
      simcall->comm_isend.result = SIMIX_comm_isend(
 
89
          simcall->issuer,
 
90
          simcall->comm_isend.rdv,
 
91
          simcall->comm_isend.task_size,
 
92
          simcall->comm_isend.rate,
 
93
          simcall->comm_isend.src_buff,
 
94
          simcall->comm_isend.src_buff_size,
 
95
          simcall->comm_isend.match_fun,
 
96
          simcall->comm_isend.clean_fun,
 
97
          simcall->comm_isend.data,
 
98
          simcall->comm_isend.detached);
 
99
      SIMIX_simcall_answer(simcall);
89
100
      break;
90
101
 
91
 
    case REQ_COMM_RECV:
 
102
    case SIMCALL_COMM_RECV:
92
103
    {
93
104
      smx_action_t comm = SIMIX_comm_irecv(
94
 
          req->issuer,
95
 
          req->comm_recv.rdv,
96
 
          req->comm_recv.dst_buff,
97
 
          req->comm_recv.dst_buff_size,
98
 
          req->comm_recv.match_fun,
99
 
          req->comm_recv.data);
100
 
      SIMIX_pre_comm_wait(req, comm, req->comm_recv.timeout, 0);
 
105
          simcall->issuer,
 
106
          simcall->comm_recv.rdv,
 
107
          simcall->comm_recv.dst_buff,
 
108
          simcall->comm_recv.dst_buff_size,
 
109
          simcall->comm_recv.match_fun,
 
110
          simcall->comm_recv.data);
 
111
      SIMIX_pre_comm_wait(simcall, comm, simcall->comm_recv.timeout, 0);
101
112
      break;
102
113
    }
103
114
 
104
 
    case REQ_COMM_IRECV:
105
 
      req->comm_irecv.result = SIMIX_comm_irecv(
106
 
          req->issuer,
107
 
          req->comm_irecv.rdv,
108
 
          req->comm_irecv.dst_buff,
109
 
          req->comm_irecv.dst_buff_size,
110
 
          req->comm_irecv.match_fun,
111
 
          req->comm_irecv.data);
112
 
      SIMIX_request_answer(req);
113
 
      break;
114
 
 
115
 
    case REQ_COMM_DESTROY:
116
 
      SIMIX_comm_destroy(req->comm_destroy.comm);
117
 
      SIMIX_request_answer(req);
118
 
      break;
119
 
 
120
 
    case REQ_COMM_CANCEL:
121
 
      SIMIX_comm_cancel(req->comm_cancel.comm);
122
 
      SIMIX_request_answer(req);
123
 
      break;
124
 
 
125
 
    case REQ_COMM_GET_REMAINS:
126
 
      req->comm_get_remains.result =
127
 
          SIMIX_comm_get_remains(req->comm_get_remains.comm);
128
 
      SIMIX_request_answer(req);
129
 
      break;
130
 
 
131
 
    case REQ_COMM_GET_STATE:
132
 
      req->comm_get_state.result =
133
 
          SIMIX_comm_get_state(req->comm_get_state.comm);
134
 
      SIMIX_request_answer(req);
135
 
      break;
136
 
 
137
 
    case REQ_COMM_GET_SRC_DATA:
138
 
      req->comm_get_src_data.result = SIMIX_comm_get_src_data(req->comm_get_src_data.comm);
139
 
      SIMIX_request_answer(req);
140
 
      break;
141
 
 
142
 
    case REQ_COMM_GET_DST_DATA:
143
 
      req->comm_get_dst_data.result = SIMIX_comm_get_dst_data(req->comm_get_dst_data.comm);
144
 
      SIMIX_request_answer(req);
145
 
      break;
146
 
 
147
 
    case REQ_COMM_GET_SRC_PROC:
148
 
      req->comm_get_src_proc.result =
149
 
          SIMIX_comm_get_src_proc(req->comm_get_src_proc.comm);
150
 
      SIMIX_request_answer(req);
151
 
      break;
152
 
 
153
 
    case REQ_COMM_GET_DST_PROC:
154
 
      req->comm_get_dst_proc.result =
155
 
          SIMIX_comm_get_dst_proc(req->comm_get_dst_proc.comm);
156
 
      SIMIX_request_answer(req);
 
115
    case SIMCALL_COMM_IRECV:
 
116
      simcall->comm_irecv.result = SIMIX_comm_irecv(
 
117
          simcall->issuer,
 
118
          simcall->comm_irecv.rdv,
 
119
          simcall->comm_irecv.dst_buff,
 
120
          simcall->comm_irecv.dst_buff_size,
 
121
          simcall->comm_irecv.match_fun,
 
122
          simcall->comm_irecv.data);
 
123
      SIMIX_simcall_answer(simcall);
 
124
      break;
 
125
 
 
126
    case SIMCALL_COMM_DESTROY:
 
127
      SIMIX_comm_destroy(simcall->comm_destroy.comm);
 
128
      SIMIX_simcall_answer(simcall);
 
129
      break;
 
130
 
 
131
    case SIMCALL_COMM_CANCEL:
 
132
      SIMIX_comm_cancel(simcall->comm_cancel.comm);
 
133
      SIMIX_simcall_answer(simcall);
 
134
      break;
 
135
 
 
136
    case SIMCALL_COMM_GET_REMAINS:
 
137
      simcall->comm_get_remains.result =
 
138
          SIMIX_comm_get_remains(simcall->comm_get_remains.comm);
 
139
      SIMIX_simcall_answer(simcall);
 
140
      break;
 
141
 
 
142
    case SIMCALL_COMM_GET_STATE:
 
143
      simcall->comm_get_state.result =
 
144
          SIMIX_comm_get_state(simcall->comm_get_state.comm);
 
145
      SIMIX_simcall_answer(simcall);
 
146
      break;
 
147
 
 
148
    case SIMCALL_COMM_GET_SRC_DATA:
 
149
      simcall->comm_get_src_data.result = SIMIX_comm_get_src_data(simcall->comm_get_src_data.comm);
 
150
      SIMIX_simcall_answer(simcall);
 
151
      break;
 
152
 
 
153
    case SIMCALL_COMM_GET_DST_DATA:
 
154
      simcall->comm_get_dst_data.result = SIMIX_comm_get_dst_data(simcall->comm_get_dst_data.comm);
 
155
      SIMIX_simcall_answer(simcall);
 
156
      break;
 
157
 
 
158
    case SIMCALL_COMM_GET_SRC_PROC:
 
159
      simcall->comm_get_src_proc.result =
 
160
          SIMIX_comm_get_src_proc(simcall->comm_get_src_proc.comm);
 
161
      SIMIX_simcall_answer(simcall);
 
162
      break;
 
163
 
 
164
    case SIMCALL_COMM_GET_DST_PROC:
 
165
      simcall->comm_get_dst_proc.result =
 
166
          SIMIX_comm_get_dst_proc(simcall->comm_get_dst_proc.comm);
 
167
      SIMIX_simcall_answer(simcall);
157
168
      break;
158
169
 
159
170
#ifdef HAVE_LATENCY_BOUND_TRACKING
160
 
    case REQ_COMM_IS_LATENCY_BOUNDED:
161
 
      req->comm_is_latency_bounded.result =
162
 
          SIMIX_comm_is_latency_bounded(req->comm_is_latency_bounded.comm);
163
 
      SIMIX_request_answer(req);
 
171
    case SIMCALL_COMM_IS_LATENCY_BOUNDED:
 
172
      simcall->comm_is_latency_bounded.result =
 
173
          SIMIX_comm_is_latency_bounded(simcall->comm_is_latency_bounded.comm);
 
174
      SIMIX_simcall_answer(simcall);
164
175
      break;
165
176
#endif
166
177
 
167
 
    case REQ_RDV_CREATE:
168
 
      req->rdv_create.result = SIMIX_rdv_create(req->rdv_create.name);
169
 
      SIMIX_request_answer(req);
170
 
      break;
171
 
 
172
 
    case REQ_RDV_DESTROY:
173
 
      SIMIX_rdv_destroy(req->rdv_destroy.rdv);
174
 
      SIMIX_request_answer(req);
175
 
      break;
176
 
 
177
 
    case REQ_RDV_GEY_BY_NAME:
178
 
      req->rdv_get_by_name.result =
179
 
        SIMIX_rdv_get_by_name(req->rdv_get_by_name.name);
180
 
      SIMIX_request_answer(req);
181
 
      break;
182
 
 
183
 
    case REQ_RDV_COMM_COUNT_BY_HOST:
184
 
      req->rdv_comm_count_by_host.result = SIMIX_rdv_comm_count_by_host(
185
 
          req->rdv_comm_count_by_host.rdv,
186
 
          req->rdv_comm_count_by_host.host);
187
 
      SIMIX_request_answer(req);
188
 
      break;
189
 
 
190
 
    case REQ_RDV_GET_HEAD:
191
 
      req->rdv_get_head.result = SIMIX_rdv_get_head(req->rdv_get_head.rdv);
192
 
      SIMIX_request_answer(req);
193
 
      break;
194
 
 
195
 
    case REQ_HOST_GET_BY_NAME:
196
 
      req->host_get_by_name.result =
197
 
        SIMIX_host_get_by_name(req->host_get_by_name.name);
198
 
      SIMIX_request_answer(req);
199
 
      break;
200
 
 
201
 
    case REQ_HOST_GET_NAME:
202
 
      req->host_get_name.result =       SIMIX_host_get_name(req->host_get_name.host);
203
 
      SIMIX_request_answer(req);
204
 
      break;
205
 
 
206
 
    case REQ_HOST_GET_PROPERTIES:
207
 
      req->host_get_properties.result =
208
 
        SIMIX_host_get_properties(req->host_get_properties.host);
209
 
      SIMIX_request_answer(req);
210
 
      break;
211
 
 
212
 
    case REQ_HOST_GET_SPEED:
213
 
      req->host_get_speed.result = 
214
 
        SIMIX_host_get_speed(req->host_get_speed.host);
215
 
      SIMIX_request_answer(req);
216
 
      break;
217
 
 
218
 
    case REQ_HOST_GET_AVAILABLE_SPEED:
219
 
      req->host_get_available_speed.result =
220
 
        SIMIX_host_get_available_speed(req->host_get_available_speed.host);
221
 
      SIMIX_request_answer(req);
222
 
      break;
223
 
 
224
 
    case REQ_HOST_GET_STATE:
225
 
      req->host_get_state.result = 
226
 
        SIMIX_host_get_state(req->host_get_state.host);
227
 
      SIMIX_request_answer(req);
228
 
      break;
229
 
 
230
 
    case REQ_HOST_GET_DATA:
231
 
      req->host_get_data.result =       SIMIX_host_get_data(req->host_get_data.host);
232
 
      SIMIX_request_answer(req);
233
 
      break;
234
 
 
235
 
    case REQ_HOST_SET_DATA:
236
 
      SIMIX_host_set_data(req->host_set_data.host, req->host_set_data.data);
237
 
      SIMIX_request_answer(req);
238
 
      break;
239
 
 
240
 
    case REQ_HOST_EXECUTE:
241
 
      req->host_execute.result = SIMIX_host_execute(
242
 
          req->host_execute.name,
243
 
          req->host_execute.host,
244
 
          req->host_execute.computation_amount,
245
 
          req->host_execute.priority);
246
 
      SIMIX_request_answer(req);
247
 
      break;
248
 
 
249
 
    case REQ_HOST_PARALLEL_EXECUTE:
250
 
      req->host_parallel_execute.result = SIMIX_host_parallel_execute(
251
 
          req->host_parallel_execute.name,
252
 
          req->host_parallel_execute.host_nb,
253
 
          req->host_parallel_execute.host_list,
254
 
          req->host_parallel_execute.computation_amount,
255
 
          req->host_parallel_execute.communication_amount,
256
 
          req->host_parallel_execute.amount,
257
 
          req->host_parallel_execute.rate);
258
 
      SIMIX_request_answer(req);
259
 
      break;
260
 
 
261
 
    case REQ_HOST_EXECUTION_DESTROY:
262
 
      SIMIX_host_execution_destroy(req->host_execution_destroy.execution);
263
 
      SIMIX_request_answer(req);
264
 
      break;
265
 
 
266
 
    case REQ_HOST_EXECUTION_CANCEL:
267
 
      SIMIX_host_execution_cancel(req->host_execution_cancel.execution);
268
 
      SIMIX_request_answer(req);
269
 
      break;
270
 
 
271
 
    case REQ_HOST_EXECUTION_GET_REMAINS:
272
 
      req->host_execution_get_remains.result =
273
 
        SIMIX_host_execution_get_remains(req->host_execution_get_remains.execution);
274
 
      SIMIX_request_answer(req);
275
 
      break;
276
 
 
277
 
    case REQ_HOST_EXECUTION_GET_STATE:
278
 
      req->host_execution_get_state.result =
279
 
        SIMIX_host_execution_get_state(req->host_execution_get_state.execution);
280
 
      SIMIX_request_answer(req);
281
 
      break;
282
 
 
283
 
    case REQ_HOST_EXECUTION_SET_PRIORITY:
 
178
    case SIMCALL_RDV_CREATE:
 
179
      simcall->rdv_create.result = SIMIX_rdv_create(simcall->rdv_create.name);
 
180
      SIMIX_simcall_answer(simcall);
 
181
      break;
 
182
 
 
183
    case SIMCALL_RDV_DESTROY:
 
184
      SIMIX_rdv_destroy(simcall->rdv_destroy.rdv);
 
185
      SIMIX_simcall_answer(simcall);
 
186
      break;
 
187
 
 
188
    case SIMCALL_RDV_GEY_BY_NAME:
 
189
      simcall->rdv_get_by_name.result =
 
190
        SIMIX_rdv_get_by_name(simcall->rdv_get_by_name.name);
 
191
      SIMIX_simcall_answer(simcall);
 
192
      break;
 
193
 
 
194
    case SIMCALL_RDV_COMM_COUNT_BY_HOST:
 
195
      simcall->rdv_comm_count_by_host.result = SIMIX_rdv_comm_count_by_host(
 
196
          simcall->rdv_comm_count_by_host.rdv,
 
197
          simcall->rdv_comm_count_by_host.host);
 
198
      SIMIX_simcall_answer(simcall);
 
199
      break;
 
200
 
 
201
    case SIMCALL_RDV_GET_HEAD:
 
202
      simcall->rdv_get_head.result = SIMIX_rdv_get_head(simcall->rdv_get_head.rdv);
 
203
      SIMIX_simcall_answer(simcall);
 
204
      break;
 
205
 
 
206
    case SIMCALL_HOST_GET_BY_NAME:
 
207
      simcall->host_get_by_name.result =
 
208
        SIMIX_host_get_by_name(simcall->host_get_by_name.name);
 
209
      SIMIX_simcall_answer(simcall);
 
210
      break;
 
211
 
 
212
    case SIMCALL_HOST_GET_NAME:
 
213
      simcall->host_get_name.result =   SIMIX_host_get_name(simcall->host_get_name.host);
 
214
      SIMIX_simcall_answer(simcall);
 
215
      break;
 
216
 
 
217
    case SIMCALL_HOST_GET_PROPERTIES:
 
218
      simcall->host_get_properties.result =
 
219
        SIMIX_host_get_properties(simcall->host_get_properties.host);
 
220
      SIMIX_simcall_answer(simcall);
 
221
      break;
 
222
 
 
223
    case SIMCALL_HOST_GET_SPEED:
 
224
      simcall->host_get_speed.result = 
 
225
        SIMIX_host_get_speed(simcall->host_get_speed.host);
 
226
      SIMIX_simcall_answer(simcall);
 
227
      break;
 
228
 
 
229
    case SIMCALL_HOST_GET_AVAILABLE_SPEED:
 
230
      simcall->host_get_available_speed.result =
 
231
        SIMIX_host_get_available_speed(simcall->host_get_available_speed.host);
 
232
      SIMIX_simcall_answer(simcall);
 
233
      break;
 
234
 
 
235
    case SIMCALL_HOST_GET_STATE:
 
236
      simcall->host_get_state.result = 
 
237
        SIMIX_host_get_state(simcall->host_get_state.host);
 
238
      SIMIX_simcall_answer(simcall);
 
239
      break;
 
240
 
 
241
    case SIMCALL_HOST_GET_DATA:
 
242
      simcall->host_get_data.result =   SIMIX_host_get_data(simcall->host_get_data.host);
 
243
      SIMIX_simcall_answer(simcall);
 
244
      break;
 
245
 
 
246
    case SIMCALL_HOST_SET_DATA:
 
247
      SIMIX_host_set_data(simcall->host_set_data.host, simcall->host_set_data.data);
 
248
      SIMIX_simcall_answer(simcall);
 
249
      break;
 
250
 
 
251
    case SIMCALL_HOST_EXECUTE:
 
252
      simcall->host_execute.result = SIMIX_host_execute(
 
253
          simcall->host_execute.name,
 
254
          simcall->host_execute.host,
 
255
          simcall->host_execute.computation_amount,
 
256
          simcall->host_execute.priority);
 
257
      SIMIX_simcall_answer(simcall);
 
258
      break;
 
259
 
 
260
    case SIMCALL_HOST_PARALLEL_EXECUTE:
 
261
      simcall->host_parallel_execute.result = SIMIX_host_parallel_execute(
 
262
          simcall->host_parallel_execute.name,
 
263
          simcall->host_parallel_execute.host_nb,
 
264
          simcall->host_parallel_execute.host_list,
 
265
          simcall->host_parallel_execute.computation_amount,
 
266
          simcall->host_parallel_execute.communication_amount,
 
267
          simcall->host_parallel_execute.amount,
 
268
          simcall->host_parallel_execute.rate);
 
269
      SIMIX_simcall_answer(simcall);
 
270
      break;
 
271
 
 
272
    case SIMCALL_HOST_EXECUTION_DESTROY:
 
273
      SIMIX_host_execution_destroy(simcall->host_execution_destroy.execution);
 
274
      SIMIX_simcall_answer(simcall);
 
275
      break;
 
276
 
 
277
    case SIMCALL_HOST_EXECUTION_CANCEL:
 
278
      SIMIX_host_execution_cancel(simcall->host_execution_cancel.execution);
 
279
      SIMIX_simcall_answer(simcall);
 
280
      break;
 
281
 
 
282
    case SIMCALL_HOST_EXECUTION_GET_REMAINS:
 
283
      simcall->host_execution_get_remains.result =
 
284
        SIMIX_host_execution_get_remains(simcall->host_execution_get_remains.execution);
 
285
      SIMIX_simcall_answer(simcall);
 
286
      break;
 
287
 
 
288
    case SIMCALL_HOST_EXECUTION_GET_STATE:
 
289
      simcall->host_execution_get_state.result =
 
290
        SIMIX_host_execution_get_state(simcall->host_execution_get_state.execution);
 
291
      SIMIX_simcall_answer(simcall);
 
292
      break;
 
293
 
 
294
    case SIMCALL_HOST_EXECUTION_SET_PRIORITY:
284
295
      SIMIX_host_execution_set_priority(
285
 
          req->host_execution_set_priority.execution,
286
 
          req->host_execution_set_priority.priority);
287
 
      SIMIX_request_answer(req);
288
 
      break;
289
 
 
290
 
    case REQ_HOST_EXECUTION_WAIT:
291
 
      SIMIX_pre_host_execution_wait(req);
292
 
      break;
293
 
 
294
 
    case REQ_PROCESS_CREATE:
 
296
          simcall->host_execution_set_priority.execution,
 
297
          simcall->host_execution_set_priority.priority);
 
298
      SIMIX_simcall_answer(simcall);
 
299
      break;
 
300
 
 
301
    case SIMCALL_HOST_EXECUTION_WAIT:
 
302
      SIMIX_pre_host_execution_wait(simcall);
 
303
      break;
 
304
 
 
305
    case SIMCALL_PROCESS_CREATE:
295
306
      SIMIX_process_create(
296
 
          req->process_create.process,
297
 
          req->process_create.name,
298
 
          req->process_create.code,
299
 
          req->process_create.data,
300
 
          req->process_create.hostname,
301
 
          req->process_create.argc,
302
 
          req->process_create.argv,
303
 
          req->process_create.properties);
304
 
      SIMIX_request_answer(req);
305
 
      break;
306
 
 
307
 
    case REQ_PROCESS_KILL:
308
 
      SIMIX_process_kill(req->process_kill.process);
309
 
      SIMIX_request_answer(req);
310
 
      break;
311
 
 
312
 
    case REQ_PROCESS_KILLALL:
313
 
      SIMIX_process_killall(req->issuer);
314
 
      SIMIX_request_answer(req);
315
 
      break;
316
 
 
317
 
    case REQ_PROCESS_CLEANUP:
318
 
      SIMIX_process_cleanup(req->process_cleanup.process);
319
 
      SIMIX_request_answer(req);
320
 
      break;
321
 
 
322
 
    case REQ_PROCESS_CHANGE_HOST:
 
307
          simcall->process_create.process,
 
308
          simcall->process_create.name,
 
309
          simcall->process_create.code,
 
310
          simcall->process_create.data,
 
311
          simcall->process_create.hostname,
 
312
          simcall->process_create.kill_time,
 
313
          simcall->process_create.argc,
 
314
          simcall->process_create.argv,
 
315
          simcall->process_create.properties);
 
316
      SIMIX_simcall_answer(simcall);
 
317
      break;
 
318
 
 
319
    case SIMCALL_PROCESS_KILL:
 
320
      SIMIX_process_kill(simcall->process_kill.process);
 
321
      SIMIX_simcall_answer(simcall);
 
322
      break;
 
323
 
 
324
    case SIMCALL_PROCESS_KILLALL:
 
325
      SIMIX_process_killall(simcall->issuer);
 
326
      SIMIX_simcall_answer(simcall);
 
327
      break;
 
328
 
 
329
    case SIMCALL_PROCESS_CLEANUP:
 
330
      SIMIX_process_cleanup(simcall->process_cleanup.process);
 
331
      SIMIX_simcall_answer(simcall);
 
332
      break;
 
333
 
 
334
    case SIMCALL_PROCESS_CHANGE_HOST:
323
335
      SIMIX_pre_process_change_host(
324
 
          req->process_change_host.process,
325
 
          req->process_change_host.dest);
326
 
      SIMIX_request_answer(req);
327
 
      break;
328
 
 
329
 
    case REQ_PROCESS_SUSPEND:
330
 
      SIMIX_pre_process_suspend(req);
331
 
      break;
332
 
 
333
 
    case REQ_PROCESS_RESUME:
334
 
      SIMIX_process_resume(req->process_resume.process, req->issuer);
335
 
      SIMIX_request_answer(req);
336
 
      break;
337
 
 
338
 
    case REQ_PROCESS_COUNT:
339
 
      req->process_count.result = SIMIX_process_count();
340
 
      SIMIX_request_answer(req);
341
 
      break;
342
 
 
343
 
    case REQ_PROCESS_GET_DATA:
344
 
      req->process_get_data.result =
345
 
        SIMIX_process_get_data(req->process_get_data.process);
346
 
      SIMIX_request_answer(req);
347
 
      break;
348
 
 
349
 
    case REQ_PROCESS_SET_DATA:
 
336
          simcall->process_change_host.process,
 
337
          simcall->process_change_host.dest);
 
338
      SIMIX_simcall_answer(simcall);
 
339
      break;
 
340
 
 
341
    case SIMCALL_PROCESS_SUSPEND:
 
342
      SIMIX_pre_process_suspend(simcall);
 
343
      break;
 
344
 
 
345
    case SIMCALL_PROCESS_RESUME:
 
346
      SIMIX_process_resume(simcall->process_resume.process, simcall->issuer);
 
347
      SIMIX_simcall_answer(simcall);
 
348
      break;
 
349
 
 
350
    case SIMCALL_PROCESS_COUNT:
 
351
      simcall->process_count.result = SIMIX_process_count();
 
352
      SIMIX_simcall_answer(simcall);
 
353
      break;
 
354
 
 
355
    case SIMCALL_PROCESS_GET_DATA:
 
356
      simcall->process_get_data.result =
 
357
        SIMIX_process_get_data(simcall->process_get_data.process);
 
358
      SIMIX_simcall_answer(simcall);
 
359
      break;
 
360
 
 
361
    case SIMCALL_PROCESS_SET_DATA:
350
362
      SIMIX_process_set_data(
351
 
          req->process_set_data.process,
352
 
          req->process_set_data.data);
353
 
      SIMIX_request_answer(req);
354
 
      break;
355
 
 
356
 
    case REQ_PROCESS_GET_HOST:
357
 
      req->process_get_host.result = SIMIX_process_get_host(req->process_get_host.process);
358
 
      SIMIX_request_answer(req);
359
 
      break;
360
 
 
361
 
    case REQ_PROCESS_GET_NAME:
362
 
      req->process_get_name.result = SIMIX_process_get_name(req->process_get_name.process);
363
 
      SIMIX_request_answer(req);
364
 
      break;
365
 
 
366
 
    case REQ_PROCESS_IS_SUSPENDED:
367
 
      req->process_is_suspended.result =
368
 
        SIMIX_process_is_suspended(req->process_is_suspended.process);
369
 
      SIMIX_request_answer(req);
370
 
      break;
371
 
 
372
 
    case REQ_PROCESS_GET_PROPERTIES:
373
 
      req->process_get_properties.result =
374
 
        SIMIX_process_get_properties(req->process_get_properties.process);
375
 
      SIMIX_request_answer(req);
376
 
      break;
377
 
 
378
 
    case REQ_PROCESS_SLEEP:
379
 
      SIMIX_pre_process_sleep(req);
 
363
          simcall->process_set_data.process,
 
364
          simcall->process_set_data.data);
 
365
      SIMIX_simcall_answer(simcall);
 
366
      break;
 
367
 
 
368
    case SIMCALL_PROCESS_GET_HOST:
 
369
      simcall->process_get_host.result = SIMIX_process_get_host(simcall->process_get_host.process);
 
370
      SIMIX_simcall_answer(simcall);
 
371
      break;
 
372
 
 
373
    case SIMCALL_PROCESS_GET_NAME:
 
374
      simcall->process_get_name.result = SIMIX_process_get_name(simcall->process_get_name.process);
 
375
      SIMIX_simcall_answer(simcall);
 
376
      break;
 
377
 
 
378
    case SIMCALL_PROCESS_IS_SUSPENDED:
 
379
      simcall->process_is_suspended.result =
 
380
        SIMIX_process_is_suspended(simcall->process_is_suspended.process);
 
381
      SIMIX_simcall_answer(simcall);
 
382
      break;
 
383
 
 
384
    case SIMCALL_PROCESS_GET_PROPERTIES:
 
385
      simcall->process_get_properties.result =
 
386
        SIMIX_process_get_properties(simcall->process_get_properties.process);
 
387
      SIMIX_simcall_answer(simcall);
 
388
      break;
 
389
 
 
390
    case SIMCALL_PROCESS_SLEEP:
 
391
      SIMIX_pre_process_sleep(simcall);
380
392
      break;
381
393
 
382
394
#ifdef HAVE_TRACING
383
 
    case REQ_SET_CATEGORY:
 
395
    case SIMCALL_SET_CATEGORY:
384
396
      SIMIX_set_category(
385
 
          req->set_category.action,
386
 
          req->set_category.category);
387
 
      SIMIX_request_answer(req);
 
397
          simcall->set_category.action,
 
398
          simcall->set_category.category);
 
399
      SIMIX_simcall_answer(simcall);
388
400
      break;
389
401
#endif
390
402
 
391
 
    case REQ_MUTEX_INIT:
392
 
      req->mutex_init.result = SIMIX_mutex_init();
393
 
      SIMIX_request_answer(req);
394
 
      break;
395
 
 
396
 
    case REQ_MUTEX_DESTROY:
397
 
      SIMIX_mutex_destroy(req->mutex_destroy.mutex);
398
 
      SIMIX_request_answer(req);
399
 
      break;
400
 
 
401
 
    case REQ_MUTEX_LOCK:
402
 
      SIMIX_pre_mutex_lock(req);
403
 
      break;
404
 
 
405
 
    case REQ_MUTEX_TRYLOCK:
406
 
      req->mutex_trylock.result =
407
 
              SIMIX_mutex_trylock(req->mutex_trylock.mutex, req->issuer);
408
 
      SIMIX_request_answer(req);
409
 
      break;
410
 
 
411
 
    case REQ_MUTEX_UNLOCK:
412
 
      SIMIX_mutex_unlock(req->mutex_unlock.mutex, req->issuer);
413
 
      SIMIX_request_answer(req);
414
 
      break;
415
 
 
416
 
    case REQ_COND_INIT:
417
 
      req->cond_init.result = SIMIX_cond_init();
418
 
      SIMIX_request_answer(req);
419
 
      break;
420
 
 
421
 
    case REQ_COND_DESTROY:
422
 
      SIMIX_cond_destroy(req->cond_destroy.cond);
423
 
      SIMIX_request_answer(req);
424
 
      break;
425
 
 
426
 
    case REQ_COND_SIGNAL:
427
 
      SIMIX_cond_signal(req->cond_signal.cond);
428
 
      SIMIX_request_answer(req);
429
 
      break;
430
 
 
431
 
    case REQ_COND_WAIT:
432
 
      SIMIX_pre_cond_wait(req);
433
 
      break;
434
 
 
435
 
    case REQ_COND_WAIT_TIMEOUT:
436
 
      SIMIX_pre_cond_wait_timeout(req);
437
 
      break;
438
 
 
439
 
    case REQ_COND_BROADCAST:
440
 
      SIMIX_cond_broadcast(req->cond_broadcast.cond);
441
 
      SIMIX_request_answer(req);
442
 
      break;
443
 
 
444
 
    case REQ_SEM_INIT:
445
 
      req->sem_init.result = SIMIX_sem_init(req->sem_init.capacity);
446
 
      SIMIX_request_answer(req);
447
 
      break;
448
 
 
449
 
    case REQ_SEM_DESTROY:
450
 
      SIMIX_sem_destroy(req->sem_destroy.sem);
451
 
      SIMIX_request_answer(req);
452
 
      break;
453
 
 
454
 
    case REQ_SEM_RELEASE:
455
 
      SIMIX_sem_release(req->sem_release.sem);
456
 
      SIMIX_request_answer(req);
457
 
      break;
458
 
 
459
 
    case REQ_SEM_WOULD_BLOCK:
460
 
      req->sem_would_block.result =
461
 
        SIMIX_sem_would_block(req->sem_would_block.sem);
462
 
      SIMIX_request_answer(req);
463
 
      break;
464
 
 
465
 
    case REQ_SEM_ACQUIRE:
466
 
      SIMIX_pre_sem_acquire(req);
467
 
      break;
468
 
 
469
 
    case REQ_SEM_ACQUIRE_TIMEOUT:
470
 
      SIMIX_pre_sem_acquire_timeout(req);
471
 
      break;
472
 
 
473
 
    case REQ_SEM_GET_CAPACITY:
474
 
      req->sem_get_capacity.result = 
475
 
        SIMIX_sem_get_capacity(req->sem_get_capacity.sem);
476
 
      SIMIX_request_answer(req);
477
 
      break;
478
 
 
479
 
    case REQ_NO_REQ:
 
403
    case SIMCALL_MUTEX_INIT:
 
404
      simcall->mutex_init.result = SIMIX_mutex_init();
 
405
      SIMIX_simcall_answer(simcall);
 
406
      break;
 
407
 
 
408
    case SIMCALL_MUTEX_DESTROY:
 
409
      SIMIX_mutex_destroy(simcall->mutex_destroy.mutex);
 
410
      SIMIX_simcall_answer(simcall);
 
411
      break;
 
412
 
 
413
    case SIMCALL_MUTEX_LOCK:
 
414
      SIMIX_pre_mutex_lock(simcall);
 
415
      break;
 
416
 
 
417
    case SIMCALL_MUTEX_TRYLOCK:
 
418
      simcall->mutex_trylock.result =
 
419
              SIMIX_mutex_trylock(simcall->mutex_trylock.mutex, simcall->issuer);
 
420
      SIMIX_simcall_answer(simcall);
 
421
      break;
 
422
 
 
423
    case SIMCALL_MUTEX_UNLOCK:
 
424
      SIMIX_mutex_unlock(simcall->mutex_unlock.mutex, simcall->issuer);
 
425
      SIMIX_simcall_answer(simcall);
 
426
      break;
 
427
 
 
428
    case SIMCALL_COND_INIT:
 
429
      simcall->cond_init.result = SIMIX_cond_init();
 
430
      SIMIX_simcall_answer(simcall);
 
431
      break;
 
432
 
 
433
    case SIMCALL_COND_DESTROY:
 
434
      SIMIX_cond_destroy(simcall->cond_destroy.cond);
 
435
      SIMIX_simcall_answer(simcall);
 
436
      break;
 
437
 
 
438
    case SIMCALL_COND_SIGNAL:
 
439
      SIMIX_cond_signal(simcall->cond_signal.cond);
 
440
      SIMIX_simcall_answer(simcall);
 
441
      break;
 
442
 
 
443
    case SIMCALL_COND_WAIT:
 
444
      SIMIX_pre_cond_wait(simcall);
 
445
      break;
 
446
 
 
447
    case SIMCALL_COND_WAIT_TIMEOUT:
 
448
      SIMIX_pre_cond_wait_timeout(simcall);
 
449
      break;
 
450
 
 
451
    case SIMCALL_COND_BROADCAST:
 
452
      SIMIX_cond_broadcast(simcall->cond_broadcast.cond);
 
453
      SIMIX_simcall_answer(simcall);
 
454
      break;
 
455
 
 
456
    case SIMCALL_SEM_INIT:
 
457
      simcall->sem_init.result = SIMIX_sem_init(simcall->sem_init.capacity);
 
458
      SIMIX_simcall_answer(simcall);
 
459
      break;
 
460
 
 
461
    case SIMCALL_SEM_DESTROY:
 
462
      SIMIX_sem_destroy(simcall->sem_destroy.sem);
 
463
      SIMIX_simcall_answer(simcall);
 
464
      break;
 
465
 
 
466
    case SIMCALL_SEM_RELEASE:
 
467
      SIMIX_sem_release(simcall->sem_release.sem);
 
468
      SIMIX_simcall_answer(simcall);
 
469
      break;
 
470
 
 
471
    case SIMCALL_SEM_WOULD_BLOCK:
 
472
      simcall->sem_would_block.result =
 
473
        SIMIX_sem_would_block(simcall->sem_would_block.sem);
 
474
      SIMIX_simcall_answer(simcall);
 
475
      break;
 
476
 
 
477
    case SIMCALL_SEM_ACQUIRE:
 
478
      SIMIX_pre_sem_acquire(simcall);
 
479
      break;
 
480
 
 
481
    case SIMCALL_SEM_ACQUIRE_TIMEOUT:
 
482
      SIMIX_pre_sem_acquire_timeout(simcall);
 
483
      break;
 
484
 
 
485
    case SIMCALL_SEM_GET_CAPACITY:
 
486
      simcall->sem_get_capacity.result = 
 
487
        SIMIX_sem_get_capacity(simcall->sem_get_capacity.sem);
 
488
      SIMIX_simcall_answer(simcall);
 
489
      break;
 
490
 
 
491
    case SIMCALL_FILE_READ:
 
492
      SIMIX_pre_file_read(simcall);
 
493
      break;
 
494
 
 
495
    case SIMCALL_FILE_WRITE:
 
496
      SIMIX_pre_file_write(simcall);
 
497
      break;
 
498
 
 
499
    case SIMCALL_FILE_OPEN:
 
500
      SIMIX_pre_file_open(simcall);
 
501
      break;
 
502
 
 
503
    case SIMCALL_FILE_CLOSE:
 
504
      SIMIX_pre_file_close(simcall);
 
505
      break;
 
506
 
 
507
    case SIMCALL_FILE_STAT:
 
508
      SIMIX_pre_file_stat(simcall);
 
509
      break;
 
510
 
 
511
    case SIMCALL_NONE:
480
512
      THROWF(arg_error,0,"Asked to do the noop syscall on %s@%s",
481
 
          SIMIX_process_get_name(req->issuer),
482
 
          SIMIX_host_get_name(SIMIX_process_get_host(req->issuer))
 
513
          SIMIX_process_get_name(simcall->issuer),
 
514
          SIMIX_host_get_name(SIMIX_process_get_host(simcall->issuer))
483
515
          );
484
516
      break;
485
517
  }
486
518
}
487
519
 
488
 
void SIMIX_request_post(smx_action_t action)
 
520
void SIMIX_simcall_post(smx_action_t action)
489
521
{
490
522
  switch (action->type) {
491
523
 
507
539
      break;
508
540
 
509
541
    case SIMIX_ACTION_IO:
 
542
      SIMIX_post_io(action);
510
543
      break;
511
544
  }
512
545
}