Mercurial > cgi-bin > hgwebdir.cgi > VMS > VMS_Implementations > VSs_impls > VSs__MC_shared_impl
view nanos-vss.c @ 47:a7c77d69d127
update for api v. nanox-0.7
| author | Nina Engelhardt <nengel@mailbox.tu-berlin.de> |
|---|---|
| date | Fri, 05 Jul 2013 15:36:42 +0200 |
| parents | 6be6b0394537 |
| children |
line source
1 #include <nanox/nanos.h>
3 #include "VSs.h"
5 /*nanos_submit
6 nanos_current_wd
7 nanos_create_wd_compact
8 nanos_handle_error
9 nanos_create_wd_and_run_compact
11 nanos_wg_wait_completion //taskwait
12 nanos_wait_on //taskwait on
13 nanos_set_lock //critical start
14 nanos_unset_lock //critical end
16 nanos_omp_set_interface
17 nanos_smp_factory*/
19 int tasks_created = 0;
21 nanos_wd_t nanos_current_wd(void) {
22 return (nanos_wd_t) ((VSsSemData*) currVP->semanticData)->taskStub;
23 }
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, nanos_region_dimension_internal_t **dimensions) {
28 *wd = NULL;
29 return NANOS_OK;
31 VSsTaskStub* ts = (VSsTaskStub*) malloc(sizeof (VSsTaskStub));
32 void* alloc_data = malloc(data_size);
33 *data = alloc_data;
34 ts->args = alloc_data;
36 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
38 taskType->fn = *((VSsTaskFnPtr*) ((nanos_device_t*) & const_data[1])->arg);
39 taskType->sizeOfArgs = data_size;
41 ts->taskType = taskType;
43 *wd = (nanos_wd_t) ts;
45 return NANOS_OK;
46 }
48 nanos_err_t nanos_submit(nanos_wd_t wd, size_t num_data_accesses, nanos_data_access_t *data_accesses, nanos_team_t team) {
50 return NANOS_UNIMPLEMENTED;
52 int32* depsTypes = malloc(sizeof (int32) * num_data_accesses);
53 size_t* depsSizes = malloc(sizeof (size_t) * num_data_accesses);
54 void** depsAddrs = malloc(sizeof (void*)*num_data_accesses);
56 int i;
57 for (i = 0; i < num_data_accesses; i++) {
58 depsAddrs[i] = (void*)((uintptr_t)data_accesses[i].address + data_accesses[i].offset );
59 depsTypes[i] = (data_accesses[i].flags.output) ? WRITER : READER;
60 depsSizes[i] = data_accesses[i].dimensions[0].size;
61 }
63 VSsTaskStub* ts = (VSsTaskStub*) wd;
67 VSsTaskType* taskType = ts->taskType;
68 taskType->numDeps = num_data_accesses;
69 taskType->depsTypes = depsTypes;
70 taskType->depsSizes = depsSizes;
73 VSsSemReq reqData;
75 reqData.reqType = submit_task;
77 reqData.taskType = taskType;
78 reqData.args = ts->args;
79 reqData.deps = depsAddrs;
80 reqData.callingSlv = currVP;
82 int32* taskID;
83 taskID = VSs__create_taskID_of_size(1);
84 taskID[1] = tasks_created++;
86 reqData.taskID = taskID;
88 free(ts);
90 VMS_WL__send_sem_request(&reqData, currVP);
92 return NANOS_OK;
93 }
95 nanos_err_t nanos_create_wd_and_run_compact( nanos_const_wd_definition_t *const_data, nanos_wd_dyn_props_t *dyn_props,
96 size_t data_size, void * data, size_t num_data_accesses, nanos_data_access_t *data_accesses,
97 nanos_copy_data_t *copies, nanos_region_dimension_internal_t *dimensions, nanos_translate_args_t translate_args ) {
100 int32* depsTypes = malloc(sizeof (int32) * num_data_accesses);
101 size_t* depsSizes = malloc(sizeof (size_t) * num_data_accesses);
102 void** depsAddrs = malloc(sizeof (void*) * num_data_accesses);
104 int i;
105 for (i = 0; i < num_data_accesses; i++) {
106 depsAddrs[i] = (void*)((uintptr_t)data_accesses[i].address + data_accesses[i].offset );
107 depsTypes[i] = (data_accesses[i].flags.output) ? WRITER : READER;
108 depsSizes[i] = data_accesses[i].dimensions[0].size;
109 }
111 /* const_data is declared as:
112 *
113 * struct nanos_const_wd_definition_local_t
114 {
115 nanos_const_wd_definition_t base;
116 nanos_device_t devices[1];
117 };
118 * and devices[0].arg is the function to call
119 * so ugly pointer tricks to get it from there
120 */
122 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
124 taskType->fn = *((VSsTaskFnPtr*) ((nanos_device_t*) & const_data[1])->arg);
125 taskType->numDeps = num_data_accesses;
126 taskType->depsTypes = depsTypes;
127 taskType->depsSizes = depsSizes;
128 taskType->sizeOfArgs = data_size;
130 VSsSemReq reqData;
132 reqData.reqType = submit_task;
134 reqData.taskType = taskType;
135 reqData.args = data;
136 reqData.deps = depsAddrs;
137 reqData.callingSlv = currVP;
139 int32* taskID;
140 taskID = VSs__create_taskID_of_size(1);
141 taskID[1] = tasks_created++;
143 reqData.taskID = taskID;
145 VMS_WL__send_sem_request(&reqData, currVP);
147 return NANOS_OK;
148 }
150 void nanos_handle_error(nanos_err_t err) {
151 exit(err);
152 }
154 nanos_err_t nanos_wg_wait_completion(nanos_wg_t wg, bool avoid_flush) {
155 VSsSemReq reqData;
157 reqData.reqType = taskwait;
158 reqData.callingSlv = currVP;
160 VMS_WL__send_sem_request(&reqData, currVP);
162 return NANOS_OK;
163 }
165 nanos_err_t nanos_wait_on( size_t num_data_accesses, nanos_data_access_t *data_accesses ) {
166 VSsSemReq reqData;
168 reqData.reqType = taskwait_on;
169 reqData.callingSlv = currVP;
171 int i;
172 for (i = 0; i < num_data_accesses; i++) {
173 reqData.args = data_accesses[i].address;
174 VMS_WL__send_sem_request(&reqData, currVP);
175 }
177 return NANOS_OK;
178 }
180 nanos_err_t nanos_set_lock(nanos_lock_t *lock) {
181 VSsSemReq reqData;
183 reqData.reqType = critical_start;
184 reqData.callingSlv = currVP;
186 reqData.criticalID = lock;
188 VMS_WL__send_sem_request(&reqData, currVP);
190 return NANOS_OK;
191 }
193 nanos_err_t nanos_unset_lock(nanos_lock_t *lock) {
194 VSsSemReq reqData;
196 reqData.reqType = critical_end;
197 reqData.callingSlv = currVP;
199 reqData.criticalID = lock;
201 VMS_WL__send_sem_request(&reqData, currVP);
203 return NANOS_OK;
204 }
206 nanos_err_t nanos_omp_barrier(void) {
207 VSsSemReq reqData;
209 reqData.reqType = barrier;
210 reqData.callingSlv = currVP;
212 VMS_WL__send_sem_request(&reqData, currVP);
214 return NANOS_OK;
215 }
217 nanos_err_t nanos_in_final(bool *result) {
218 *result = false;
219 return NANOS_OK;
220 }
222 void * nanos_smp_factory(void *args) {
223 return NULL;
224 }
226 void nanos_omp_set_interface(void * arg) {
227 return;
228 }