Mercurial > cgi-bin > hgwebdir.cgi > VMS > VMS_Implementations > VSs_impls > VSs__MC_shared_impl

view nanos-vss.c @ 44:7e7f37aa2f61

find changesets by author, revision, files, or words in the commit message
fix barrier
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Tue, 11 Jun 2013 15:40:51 +0200
parents bb6fbcbce14d
children 19114b7a2357
line source
1 #include <nanox/nanos.h>
2
3 #include "VSs.h"
4
5 /*nanos_submit
6 nanos_current_wd
7 nanos_create_wd_compact
8 nanos_handle_error
9 nanos_create_wd_and_run_compact
10
11 nanos_wg_wait_completion //taskwait
12 nanos_wait_on //taskwait on
13 nanos_set_lock //critical start
14 nanos_unset_lock //critical end
15
16 nanos_omp_set_interface
17 nanos_smp_factory*/
18
19 int tasks_created = 0;
20
21 nanos_wd_t nanos_current_wd(void) {
22 return (nanos_wd_t) ((VSsSemData*) currVP->semanticData)->taskStub;
23 }
24
25 nanos_err_t nanos_create_wd_compact(nanos_wd_t *wd, nanos_const_wd_definition_t *const_data, nanos_wd_dyn_props_t *dyn_props,
26 size_t data_size, void ** data, nanos_wg_t wg, nanos_copy_data_t **copies) {
27
28 *wd = NULL;
29 return NANOS_OK;
30
31 VSsTaskStub* ts = (VSsTaskStub*) malloc(sizeof (VSsTaskStub));
32 void* alloc_data = malloc(data_size);
33 *data = alloc_data;
34 ts->args = alloc_data;
35
36 nanos_device_t* dev = (nanos_device_t*) &const_data[1];
37
38 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
39
40 taskType->fn = *((VSsTaskFnPtr*) dev[0].arg);
41 taskType->sizeOfArgs = data_size;
42
43 ts->taskType = taskType;
44
45 *wd = (nanos_wd_t) ts;
46
47 return NANOS_OK;
48 }
49
50 nanos_err_t nanos_submit(nanos_wd_t wd, size_t num_deps, nanos_dependence_t *deps, nanos_team_t team) {
51
52 return NANOS_UNIMPLEMENTED;
53
54 int32* depsTypes = malloc(sizeof (int32) * num_deps);
55 size_t* depsSizes = malloc(sizeof (size_t) * num_deps);
56 void** depsAddrs = malloc(sizeof (void*)*num_deps);
57
58 int i;
59 for (i = 0; i < num_deps; i++) {
60 depsAddrs[i] = (void *) ( (char *) (*deps[i].address) + deps[i].offset );
61 depsTypes[i] = (deps[i].flags.output) ? WRITER : READER;
62 depsSizes[i] = deps[i].size;
63 }
64
65 VSsTaskStub* ts = (VSsTaskStub*) wd;
66
67
68
69 VSsTaskType* taskType = ts->taskType;
70 taskType->numDeps = num_deps;
71 taskType->depsTypes = depsTypes;
72 taskType->depsSizes = depsSizes;
73
74
75 VSsSemReq reqData;
76
77 reqData.reqType = submit_task;
78
79 reqData.taskType = taskType;
80 reqData.args = ts->args;
81 reqData.deps = depsAddrs;
82 reqData.callingSlv = currVP;
83
84 int32* taskID;
85 taskID = VSs__create_taskID_of_size(1);
86 taskID[1] = tasks_created++;
87
88 reqData.taskID = taskID;
89
90 free(ts);
91
92 VMS_WL__send_sem_request(&reqData, currVP);
93
94 return NANOS_OK;
95 }
96
97 nanos_err_t nanos_create_wd_and_run_compact(nanos_const_wd_definition_t *const_data, nanos_wd_dyn_props_t *dyn_props,
98 size_t data_size, void * data, size_t num_deps, nanos_dependence_t *deps,
99 nanos_copy_data_t *copies, nanos_translate_args_t translate_args) {
100
101
102 int32* depsTypes = malloc(sizeof (int32) * num_deps);
103 size_t* depsSizes = malloc(sizeof (size_t) * num_deps);
104 void** depsAddrs = malloc(sizeof (void*) * num_deps);
105
106 int i;
107 for (i = 0; i < num_deps; i++) {
108 depsAddrs[i] = (void *) ( (char *) (*deps[i].address) + deps[i].offset );
109 depsTypes[i] = (deps[i].flags.output) ? WRITER : READER;
110 depsSizes[i] = deps[i].size;
111 }
112
113 /* const_data is declared as:
114 *
115 * struct nanos_const_wd_definition_local_t
116 {
117 nanos_const_wd_definition_t base;
118 nanos_device_t devices[1];
119 };
120 * and devices[0].arg is the function to call
121 * so ugly pointer tricks to get it from there
122 */
123
124 nanos_device_t* dev = (nanos_device_t*) &const_data[1];
125
126 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
127
128 taskType->fn = *((VSsTaskFnPtr*) dev[0].arg);
129 taskType->numDeps = num_deps;
130 taskType->depsTypes = depsTypes;
131 taskType->depsSizes = depsSizes;
132 taskType->sizeOfArgs = data_size;
133
134 VSsSemReq reqData;
135
136 reqData.reqType = submit_task;
137
138 reqData.taskType = taskType;
139 reqData.args = data;
140 reqData.deps = depsAddrs;
141 reqData.callingSlv = currVP;
142
143 int32* taskID;
144 taskID = VSs__create_taskID_of_size(1);
145 taskID[1] = tasks_created++;
146
147 reqData.taskID = taskID;
148
149 VMS_WL__send_sem_request(&reqData, currVP);
150
151 return NANOS_OK;
152 }
153
154 void nanos_handle_error(nanos_err_t err) {
155 exit(err);
156 }
157
158 nanos_err_t nanos_wg_wait_completion(nanos_wg_t wg, bool avoid_flush) {
159 VSsSemReq reqData;
160
161 reqData.reqType = taskwait;
162 reqData.callingSlv = currVP;
163
164 VMS_WL__send_sem_request(&reqData, currVP);
165
166 return NANOS_OK;
167 }
168
169 nanos_err_t nanos_wait_on(size_t num_deps, nanos_dependence_t *deps) {
170 VSsSemReq reqData;
171
172 reqData.reqType = taskwait_on;
173 reqData.callingSlv = currVP;
174
175 int i;
176 for (i = 0; i < num_deps; i++) {
177 reqData.args = deps[i].address;
178 VMS_WL__send_sem_request(&reqData, currVP);
179 }
180
181 return NANOS_OK;
182 }
183
184 nanos_err_t nanos_set_lock(nanos_lock_t *lock) {
185 VSsSemReq reqData;
186
187 reqData.reqType = critical_start;
188 reqData.callingSlv = currVP;
189
190 reqData.criticalID = lock;
191
192 VMS_WL__send_sem_request(&reqData, currVP);
193
194 return NANOS_OK;
195 }
196
197 nanos_err_t nanos_unset_lock(nanos_lock_t *lock) {
198 VSsSemReq reqData;
199
200 reqData.reqType = critical_end;
201 reqData.callingSlv = currVP;
202
203 reqData.criticalID = lock;
204
205 VMS_WL__send_sem_request(&reqData, currVP);
206
207 return NANOS_OK;
208 }
209
210 nanos_err_t nanos_omp_barrier ( void ){
211 VSsSemReq reqData;
212
213 reqData.reqType = barrier;
214 reqData.callingSlv = currVP;
215
216 VMS_WL__send_sem_request(&reqData, currVP);
217
218 return NANOS_OK;
219 }
220
221 void * nanos_smp_factory( void *args){
222 return NULL;
223 }
224
225 void nanos_omp_set_interface ( void * arg){
226 return;
227 }