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

comparison nanos-vss.c @ 48:b8bb94b990c4

find changesets by author, revision, files, or words in the commit message
fix: 0 dependency tasks were never started
author Nina Engelhardt <nengel@mailbox.tu-berlin.de>
date Tue, 09 Jul 2013 11:50:09 +0200
parents 6be6b0394537
children
comparison
equal deleted inserted replaced
5:c4ba92ec66ac 6:ee0002916d5a
21 nanos_wd_t nanos_current_wd(void) { 21 nanos_wd_t nanos_current_wd(void) {
22 return (nanos_wd_t) ((VSsSemData*) currVP->semanticData)->taskStub; 22 return (nanos_wd_t) ((VSsSemData*) currVP->semanticData)->taskStub;
23 } 23 }
24 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, 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) { 26 size_t data_size, void ** data, nanos_wg_t wg, nanos_copy_data_t **copies, nanos_region_dimension_internal_t **dimensions) {
27 27
28 *wd = NULL; 28 *wd = NULL;
29 return NANOS_OK; 29 return NANOS_OK;
30 30
31 VSsTaskStub* ts = (VSsTaskStub*) malloc(sizeof (VSsTaskStub)); 31 VSsTaskStub* ts = (VSsTaskStub*) malloc(sizeof (VSsTaskStub));
32 void* alloc_data = malloc(data_size); 32 void* alloc_data = malloc(data_size);
33 *data = alloc_data; 33 *data = alloc_data;
34 ts->args = alloc_data; 34 ts->args = alloc_data;
35 35
36 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType)); 36 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
37 37
38 taskType->fn = *((VSsTaskFnPtr*)((nanos_device_t*) &const_data[1])->arg); 38 taskType->fn = *((VSsTaskFnPtr*) ((nanos_device_t*) & const_data[1])->arg);
39 taskType->sizeOfArgs = data_size; 39 taskType->sizeOfArgs = data_size;
40 40
41 ts->taskType = taskType; 41 ts->taskType = taskType;
42 42
43 *wd = (nanos_wd_t) ts; 43 *wd = (nanos_wd_t) ts;
44 44
45 return NANOS_OK; 45 return NANOS_OK;
46 } 46 }
47 47
48 nanos_err_t nanos_submit(nanos_wd_t wd, size_t num_deps, nanos_dependence_t *deps, nanos_team_t team) { 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) {
49 49
50 return NANOS_UNIMPLEMENTED; 50 return NANOS_UNIMPLEMENTED;
51 51
52 int32* depsTypes = malloc(sizeof (int32) * num_deps); 52 int32* depsTypes = malloc(sizeof (int32) * num_data_accesses);
53 size_t* depsSizes = malloc(sizeof (size_t) * num_deps); 53 size_t* depsSizes = malloc(sizeof (size_t) * num_data_accesses);
54 void** depsAddrs = malloc(sizeof (void*)*num_deps); 54 void** depsAddrs = malloc(sizeof (void*)*num_data_accesses);
55 55
56 int i; 56 int i;
57 for (i = 0; i < num_deps; i++) { 57 for (i = 0; i < num_data_accesses; i++) {
58 depsAddrs[i] = (void *) ( (char *) (*deps[i].address) + deps[i].offset ); 58 depsAddrs[i] = (void*)((uintptr_t)data_accesses[i].address + data_accesses[i].offset );
59 depsTypes[i] = (deps[i].flags.output) ? WRITER : READER; 59 depsTypes[i] = (data_accesses[i].flags.output) ? WRITER : READER;
60 depsSizes[i] = deps[i].size; 60 depsSizes[i] = data_accesses[i].dimensions[0].size;
61 } 61 }
62 62
63 VSsTaskStub* ts = (VSsTaskStub*) wd; 63 VSsTaskStub* ts = (VSsTaskStub*) wd;
64 64
65 65
66 66
67 VSsTaskType* taskType = ts->taskType; 67 VSsTaskType* taskType = ts->taskType;
68 taskType->numDeps = num_deps; 68 taskType->numDeps = num_data_accesses;
69 taskType->depsTypes = depsTypes; 69 taskType->depsTypes = depsTypes;
70 taskType->depsSizes = depsSizes; 70 taskType->depsSizes = depsSizes;
71 71
72 72
73 VSsSemReq reqData; 73 VSsSemReq reqData;
80 reqData.callingSlv = currVP; 80 reqData.callingSlv = currVP;
81 81
82 int32* taskID; 82 int32* taskID;
83 taskID = VSs__create_taskID_of_size(1); 83 taskID = VSs__create_taskID_of_size(1);
84 taskID[1] = tasks_created++; 84 taskID[1] = tasks_created++;
85 85
86 reqData.taskID = taskID; 86 reqData.taskID = taskID;
87 87
88 free(ts); 88 free(ts);
89 89
90 VMS_WL__send_sem_request(&reqData, currVP); 90 VMS_WL__send_sem_request(&reqData, currVP);
91 91
92 return NANOS_OK; 92 return NANOS_OK;
93 } 93 }
94 94
95 nanos_err_t nanos_create_wd_and_run_compact(nanos_const_wd_definition_t *const_data, nanos_wd_dyn_props_t *dyn_props, 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_deps, nanos_dependence_t *deps, 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_translate_args_t translate_args) { 97 nanos_copy_data_t *copies, nanos_region_dimension_internal_t *dimensions, nanos_translate_args_t translate_args ) {
98 98
99 99
100 int32* depsTypes = malloc(sizeof (int32) * num_deps); 100 int32* depsTypes = malloc(sizeof (int32) * num_data_accesses);
101 size_t* depsSizes = malloc(sizeof (size_t) * num_deps); 101 size_t* depsSizes = malloc(sizeof (size_t) * num_data_accesses);
102 void** depsAddrs = malloc(sizeof (void*) * num_deps); 102 void** depsAddrs = malloc(sizeof (void*) * num_data_accesses);
103 103
104 int i; 104 int i;
105 for (i = 0; i < num_deps; i++) { 105 for (i = 0; i < num_data_accesses; i++) {
106 depsAddrs[i] = (void *) ( (char *) (*deps[i].address) + deps[i].offset ); 106 depsAddrs[i] = (void*)((uintptr_t)data_accesses[i].address + data_accesses[i].offset );
107 depsTypes[i] = (deps[i].flags.output) ? WRITER : READER; 107 depsTypes[i] = (data_accesses[i].flags.output) ? WRITER : READER;
108 depsSizes[i] = deps[i].size; 108 depsSizes[i] = data_accesses[i].dimensions[0].size;
109 } 109 }
110 110
111 /* const_data is declared as: 111 /* const_data is declared as:
112 * 112 *
113 * struct nanos_const_wd_definition_local_t 113 * struct nanos_const_wd_definition_local_t
119 * so ugly pointer tricks to get it from there 119 * so ugly pointer tricks to get it from there
120 */ 120 */
121 121
122 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType)); 122 VSsTaskType* taskType = (VSsTaskType*) malloc(sizeof (VSsTaskType));
123 123
124 taskType->fn = *((VSsTaskFnPtr*)((nanos_device_t*) &const_data[1])->arg); 124 taskType->fn = *((VSsTaskFnPtr*) ((nanos_device_t*) & const_data[1])->arg);
125 taskType->numDeps = num_deps; 125 taskType->numDeps = num_data_accesses;
126 taskType->depsTypes = depsTypes; 126 taskType->depsTypes = depsTypes;
127 taskType->depsSizes = depsSizes; 127 taskType->depsSizes = depsSizes;
128 taskType->sizeOfArgs = data_size; 128 taskType->sizeOfArgs = data_size;
129 129
130 VSsSemReq reqData; 130 VSsSemReq reqData;
137 reqData.callingSlv = currVP; 137 reqData.callingSlv = currVP;
138 138
139 int32* taskID; 139 int32* taskID;
140 taskID = VSs__create_taskID_of_size(1); 140 taskID = VSs__create_taskID_of_size(1);
141 taskID[1] = tasks_created++; 141 taskID[1] = tasks_created++;
142 142
143 reqData.taskID = taskID; 143 reqData.taskID = taskID;
144 144
145 VMS_WL__send_sem_request(&reqData, currVP); 145 VMS_WL__send_sem_request(&reqData, currVP);
146 146
147 return NANOS_OK; 147 return NANOS_OK;
160 VMS_WL__send_sem_request(&reqData, currVP); 160 VMS_WL__send_sem_request(&reqData, currVP);
161 161
162 return NANOS_OK; 162 return NANOS_OK;
163 } 163 }
164 164
165 nanos_err_t nanos_wait_on(size_t num_deps, nanos_dependence_t *deps) { 165 nanos_err_t nanos_wait_on( size_t num_data_accesses, nanos_data_access_t *data_accesses ) {
166 VSsSemReq reqData; 166 VSsSemReq reqData;
167 167
168 reqData.reqType = taskwait_on; 168 reqData.reqType = taskwait_on;
169 reqData.callingSlv = currVP; 169 reqData.callingSlv = currVP;
170 170
171 int i; 171 int i;
172 for (i = 0; i < num_deps; i++) { 172 for (i = 0; i < num_data_accesses; i++) {
173 reqData.args = deps[i].address; 173 reqData.args = data_accesses[i].address;
174 VMS_WL__send_sem_request(&reqData, currVP); 174 VMS_WL__send_sem_request(&reqData, currVP);
175 } 175 }
176 176
177 return NANOS_OK; 177 return NANOS_OK;
178 } 178 }
184 reqData.callingSlv = currVP; 184 reqData.callingSlv = currVP;
185 185
186 reqData.criticalID = lock; 186 reqData.criticalID = lock;
187 187
188 VMS_WL__send_sem_request(&reqData, currVP); 188 VMS_WL__send_sem_request(&reqData, currVP);
189 189
190 return NANOS_OK; 190 return NANOS_OK;
191 } 191 }
192 192
193 nanos_err_t nanos_unset_lock(nanos_lock_t *lock) { 193 nanos_err_t nanos_unset_lock(nanos_lock_t *lock) {
194 VSsSemReq reqData; 194 VSsSemReq reqData;
197 reqData.callingSlv = currVP; 197 reqData.callingSlv = currVP;
198 198
199 reqData.criticalID = lock; 199 reqData.criticalID = lock;
200 200
201 VMS_WL__send_sem_request(&reqData, currVP); 201 VMS_WL__send_sem_request(&reqData, currVP);
202 202
203 return NANOS_OK; 203 return NANOS_OK;
204 } 204 }
205 205
206 nanos_err_t nanos_omp_barrier ( void ){ 206 nanos_err_t nanos_omp_barrier(void) {
207 VSsSemReq reqData; 207 VSsSemReq reqData;
208 208
209 reqData.reqType = barrier; 209 reqData.reqType = barrier;
210 reqData.callingSlv = currVP; 210 reqData.callingSlv = currVP;
211 211
212 VMS_WL__send_sem_request(&reqData, currVP); 212 VMS_WL__send_sem_request(&reqData, currVP);
213 213
214 return NANOS_OK; 214 return NANOS_OK;
215 } 215 }
216 216
217 nanos_err_t nanos_in_final(bool *result){ 217 nanos_err_t nanos_in_final(bool *result) {
218 *result = false; 218 *result = false;
219 return NANOS_OK; 219 return NANOS_OK;
220 } 220 }
221 221
222 void * nanos_smp_factory( void *args){ 222 void * nanos_smp_factory(void *args) {
223 return NULL; 223 return NULL;
224 } 224 }
225 225
226 void nanos_omp_set_interface ( void * arg){ 226 void nanos_omp_set_interface(void * arg) {
227 return; 227 return;
228 } 228 }