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

comparison nanos-vss.c @ 40:df464a215387

find changesets by author, revision, files, or words in the commit message
add implementations of (some) nanos api functions
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Mon, 03 Jun 2013 18:49:19 +0200
parents
children 37bb39da5ff1
comparison
equal deleted inserted replaced
-1:000000000000 0:ce7b08645625
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 nanos_wd_t nanos_current_wd(void) {
20 return (nanos_wd_t) ((VSsSemData*) currVP->semanticData)->taskStub;
21 }
22
23 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,
24 size_t data_size, void ** data, nanos_wg_t wg, nanos_copy_data_t **copies) {
25 VSsTaskStub* ts = (VSsTaskStub*) malloc(sizeof (VSsTaskStub));
26 void* alloc_data = malloc(data_size);
27 *data = alloc_data;
28 ts->args = alloc_data;
29
30 nanos_device_t* dev = (nanos_device_t*) &const_data[1];
31
32 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
33
34 taskType->fn = *((VSsTaskFnPtr*) dev[0].arg);
35 taskType->sizeOfArgs = data_size;
36
37 ts->taskType = taskType;
38
39 *wd = (nanos_wd_t) ts;
40
41 return NANOS_OK;
42 }
43
44 nanos_err_t nanos_submit(nanos_wd_t wd, size_t num_deps, nanos_dependence_t *deps, nanos_team_t team) {
45
46 int32* depsTypes = malloc(sizeof (int32) * num_deps);
47 size_t* depsSizes = malloc(sizeof (size_t) * num_deps);
48 void** depsAddrs = malloc(sizeof (void*)*num_deps);
49
50 int i;
51 for (i = 0; i < num_deps; i++) {
52 depsAddrs[i] = deps[i].address;
53 depsTypes[i] = (deps[i].flags.output) ? WRITER : READER;
54 depsSizes[i] = deps[i].size;
55 }
56
57 VSsTaskStub* ts = (VSsTaskStub*) wd;
58
59
60
61 VSsTaskType* taskType = ts->taskType;
62 taskType->numDeps = num_deps;
63 taskType->depsTypes = depsTypes;
64 taskType->depsSizes = depsSizes;
65
66
67 VSsSemReq reqData;
68
69 reqData.reqType = submit_task;
70
71 reqData.taskType = taskType;
72 reqData.args = ts->args;
73 reqData.deps = depsAddrs;
74 reqData.callingSlv = currVP;
75
76 reqData.taskID = NULL;
77
78 free(ts);
79
80 VMS_WL__send_sem_request(&reqData, currVP);
81
82 return NANOS_OK;
83 }
84
85 nanos_err_t nanos_create_wd_and_run_compact(nanos_const_wd_definition_t *const_data, nanos_wd_dyn_props_t *dyn_props,
86 size_t data_size, void * data, size_t num_deps, nanos_dependence_t *deps,
87 nanos_copy_data_t *copies, nanos_translate_args_t translate_args) {
88
89
90 int32* depsTypes = malloc(sizeof (int32) * num_deps);
91 size_t* depsSizes = malloc(sizeof (size_t) * num_deps);
92 void** depsAddrs = malloc(sizeof (void*)*num_deps);
93
94 int i;
95 for (i = 0; i < num_deps; i++) {
96 depsAddrs[i] = deps[i].address;
97 depsTypes[i] = (deps[i].flags.output) ? WRITER : READER;
98 depsSizes[i] = deps[i].size;
99 }
100
101 /* const_data is declared as:
102 *
103 * struct nanos_const_wd_definition_local_t
104 {
105 nanos_const_wd_definition_t base;
106 nanos_device_t devices[1];
107 };
108 * and devices[0].arg is the function to call
109 * so ugly pointer tricks to get it from there
110 */
111
112 nanos_device_t* dev = (nanos_device_t*) &const_data[1];
113
114 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
115
116 taskType->fn = *((VSsTaskFnPtr*) dev[0].arg);
117 taskType->numDeps = num_deps;
118 taskType->depsTypes = depsTypes;
119 taskType->depsSizes = depsSizes;
120 taskType->sizeOfArgs = data_size;
121
122 VSsSemReq reqData;
123
124 reqData.reqType = submit_task;
125
126 reqData.taskType = taskType;
127 reqData.args = data;
128 reqData.deps = depsAddrs;
129 reqData.callingSlv = currVP;
130
131 reqData.taskID = NULL;
132
133 VMS_WL__send_sem_request(&reqData, currVP);
134
135 return NANOS_OK;
136 }
137
138 void nanos_handle_error(nanos_err_t err) {
139 exit(err);
140 }
141
142 nanos_err_t nanos_wg_wait_completion(nanos_wg_t wg, bool avoid_flush) {
143 VSsSemReq reqData;
144
145 reqData.reqType = taskwait;
146 reqData.callingSlv = currVP;
147
148 VMS_WL__send_sem_request(&reqData, currVP);
149
150 return NANOS_OK;
151 }
152
153 nanos_err_t nanos_wait_on(size_t num_deps, nanos_dependence_t *deps) {
154 VSsSemReq reqData;
155
156 reqData.reqType = taskwait_on;
157 reqData.callingSlv = currVP;
158
159 int i;
160 for (i = 0; i < num_deps; i++) {
161 reqData.args = deps[i].address;
162 VMS_WL__send_sem_request(&reqData, currVP);
163 }
164
165 return NANOS_OK;
166 }
167
168 nanos_err_t nanos_set_lock(nanos_lock_t *lock) {
169 VSsSemReq reqData;
170
171 reqData.reqType = critical_start;
172 reqData.callingSlv = currVP;
173
174 reqData.criticalID = lock;
175
176 VMS_WL__send_sem_request(&reqData, currVP);
177
178 return NANOS_OK;
179 }
180
181 nanos_err_t nanos_unset_lock(nanos_lock_t *lock) {
182 VSsSemReq reqData;
183
184 reqData.reqType = critical_end;
185 reqData.callingSlv = currVP;
186
187 reqData.criticalID = lock;
188
189 VMS_WL__send_sem_request(&reqData, currVP);
190
191 return NANOS_OK;
192 }
193
194 void * nanos_smp_factory( void *args){
195 return NULL;
196 }
197
198 void nanos_omp_set_interface ( void * arg){
199 return;
200 }