/[escript]/trunk/escript/src/Taipan.cpp
ViewVC logotype

Annotation of /trunk/escript/src/Taipan.cpp

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1628 - (hide annotations)
Fri Jul 11 13:12:46 2008 UTC (11 years, 3 months ago) by phornby
File size: 8068 byte(s)

Merge in /branches/windows_from_1456_trunk_1620_merged_in branch.

You will find a preserved pre-merge trunk in tags under tags/trunk_at_1625.
That will be useful for diffing & checking on my stupidity.

Here is a list of the conflicts and their resolution at this
point in time.


=================================================================================
(LLWS == looks like white space).

finley/src/Assemble_addToSystemMatrix.c - resolve to branch - unused var. may be wrong.....
finley/src/CPPAdapter/SystemMatrixAdapter.cpp - resolve to branch - LLWS
finley/src/CPPAdapter/MeshAdapter.cpp - resolve to branch - LLWS
paso/src/PCG.c - resolve to branch - unused var fixes.
paso/src/SolverFCT.c - resolve to branch - LLWS
paso/src/FGMRES.c - resolve to branch - LLWS
paso/src/Common.h - resolve to trunk version. It's omp.h's include... not sure it's needed,
but for the sake of saftey.....
paso/src/Functions.c - resolve to branch version, indentation/tab removal and return error
on bad unimplemented Paso_FunctionCall.
paso/src/SolverFCT_solve.c - resolve to branch version, unused vars
paso/src/SparseMatrix_MatrixVector.c - resolve to branch version, unused vars.
escript/src/Utils.cpp - resloved to branch, needs WinSock2.h
escript/src/DataExpanded.cpp - resolved to branch version - LLWS
escript/src/DataFactory.cpp - resolve to branch version
=================================================================================

This currently passes tests on linux (debian), but is not checked on windows or Altix yet.

This checkin is to make a trunk I can check out for windows to do tests on it.

Known outstanding problem is in the operator=() method of exceptions
causing warning messages on the intel compilers.

May the God of doughnuts have mercy on my soul.


1 jgs 121
2 ksteube 1312 /* $Id$ */
3    
4     /*******************************************************
5     *
6     * Copyright 2003-2007 by ACceSS MNRF
7     * Copyright 2007 by University of Queensland
8     *
9     * http://esscc.uq.edu.au
10     * Primary Business: Queensland, Australia
11     * Licensed under the Open Software License version 3.0
12     * http://www.opensource.org/licenses/osl-3.0.php
13     *
14     *******************************************************/
15    
16 jgs 474 #include "Taipan.h"
17 jgs 121
18 jgs 477 #include <iostream>
19     #include <cassert>
20    
21     #ifdef _OPENMP
22     #include <omp.h>
23     #endif
24    
25 jgs 121 using namespace std;
26    
27     namespace escript {
28    
29     Taipan::Taipan() :
30     memTable_Root(0),
31     totalElements(0)
32     {
33 jgs 149 // create and initialise a new StatTable
34     statTable = new Taipan_StatTable;
35     clear_stats();
36 jgs 121 }
37    
38     Taipan::~Taipan() {
39    
40 jgs 151 long len=0;
41 jgs 121 Taipan_MemTable *tab;
42     Taipan_MemTable *tab_next;
43    
44 jgs 149 // dump memory usage statistics
45     dump_stats();
46    
47     // deallocate StatTable object
48     delete statTable;
49    
50 jgs 121 // deallocate all managed arrays and the memTable
51     tab = memTable_Root;
52     while (tab != 0) {
53     tab_next = tab->next;
54 jgs 151 len = tab->dim * tab->N;
55     totalElements -= len;
56 jgs 121 delete[] tab->array;
57     delete tab;
58     tab = tab_next;
59     }
60    
61 jgs 151 assert(totalElements == 0);
62    
63 jgs 121 // clear the MemTable root node
64     memTable_Root = 0;
65    
66 jgs 151 // reset totalElements counter
67 jgs 121 totalElements = -1;
68     }
69    
70 gross 797 void
71     Taipan::release_unused_arrays()
72     {
73     long len=0;
74     Taipan_MemTable *tab;
75     Taipan_MemTable *tab_next, *tab_prev=0;
76     tab = memTable_Root;
77     while (tab != 0) {
78     tab_next = tab->next;
79     if (tab->free) {
80     delete[] tab->array;
81     len += tab->dim * tab->N;
82     if (tab_prev != 0) {
83     tab_prev->next = tab->next;
84     } else {
85     memTable_Root = tab->next;
86     }
87     delete tab;
88     // increment count of arrays dealloced
89     statTable->deallocations++;
90     } else {
91     tab_prev = tab;
92     }
93     tab = tab_next;
94     }
95     totalElements -= len;
96     statTable->deallocated_elements += len;
97     cout << len*8./1048576 << " Mbytes unused memory has been released." << endl;
98     }
99    
100    
101 jgs 121 double*
102     Taipan::new_array(int dim, int N) {
103    
104     assert(totalElements >= 0);
105    
106     int len = 0;
107 jgs 122 #ifdef _OPENMP
108     int numThreads = omp_get_num_threads();
109     #else
110 jgs 121 int numThreads = 1;
111 jgs 122 #endif
112 jgs 121
113     Taipan_MemTable *tab;
114     Taipan_MemTable *new_tab;
115     Taipan_MemTable *tab_prev;
116    
117 jgs 151 // increment count of alloc operations called
118     statTable->requests++;
119 jgs 121
120     // is a suitable array already available?
121     if (memTable_Root != 0) {
122     tab = memTable_Root;
123     while (tab != 0) {
124     if (tab->dim == dim &&
125     tab->N == N &&
126     tab->free &&
127     tab->numThreads == numThreads) {
128     tab->free = false;
129     return tab->array;
130     }
131     tab_prev = tab;
132     tab = tab->next;
133     }
134     }
135    
136     // otherwise a new array must be allocated
137    
138     // create the corresponding memTable entry
139     len = dim * N;
140     new_tab = new Taipan_MemTable;
141     new_tab->dim = dim;
142     new_tab->N = N;
143     new_tab->numThreads = numThreads;
144     new_tab->free = false;
145     new_tab->next = 0;
146     if (memTable_Root == 0) {
147     memTable_Root = new_tab;
148     } else {
149     tab_prev->next = new_tab;
150     }
151    
152     // allocate and initialise the new array
153     new_tab->array = new double[len];
154 jgs 122 int i,j;
155 jgs 151 if (N==1) {
156     for (j=0; j<dim; j++)
157     new_tab->array[j]=0.0;
158     } else if (N>1) {
159     #pragma omp parallel for private(i,j) schedule(static)
160     for (i=0; i<N; i++) {
161     for (j=0; j<dim; j++)
162     new_tab->array[j+dim*i]=0.0;
163 jgs 121 }
164     }
165 jgs 151
166 jgs 121 totalElements += len;
167    
168 jgs 151 // update maximum table size
169     statTable->max_tab_size = (statTable->max_tab_size < totalElements) ? totalElements : statTable->max_tab_size;
170    
171 jgs 149 // increment count of arrays allocated
172 jgs 151 statTable->allocations++;
173 jgs 149
174     // increment count of elements allocated
175 jgs 151 statTable->allocated_elements += len;
176 jgs 149
177 jgs 121 return new_tab->array;
178     }
179    
180     void
181     Taipan::delete_array(double* array) {
182    
183     assert(totalElements >= 0);
184    
185     int N;
186     int len = 0;
187     bool found = false;
188    
189     Taipan_MemTable *tab;
190     Taipan_MemTable *tab_next;
191     Taipan_MemTable *tab_prev = 0;
192    
193 jgs 151 // increment count of free operations called
194     statTable->frees++;
195    
196     if (array == 0) {
197     // have been given an empty array, so quit now
198     return;
199     }
200    
201 jgs 121 if (memTable_Root != 0) {
202    
203     // find the table entry for this array and mark it as free
204     tab = memTable_Root;
205     while (tab != 0) {
206     if (tab->array == array) {
207     N = tab->N;
208     tab->free = true;
209     found = true;
210     break;
211     }
212     tab = tab->next;
213     }
214     if (!found) {
215     // this wasn't an array under management, so quit now
216     return;
217     }
218    
219 jgs 151 if (N<=1) {
220     // we never deallocate arrays with N<=1, so quit now
221     return;
222     }
223 jgs 149
224 jgs 121 // are there any N block arrays still in use?
225     tab = memTable_Root;
226     while (tab != 0) {
227 jgs 151 if (tab->N==N && !tab->free)
228 jgs 121 return;
229     tab = tab->next;
230     }
231    
232     // if not, all N block arrays are deallocated
233     tab = memTable_Root;
234     while (tab != 0) {
235     tab_next = tab->next;
236     if (tab->N == N) {
237     delete[] tab->array;
238     len += tab->dim * N;
239     if (tab_prev != 0) {
240     tab_prev->next = tab->next;
241     } else {
242     memTable_Root = tab->next;
243     }
244     delete tab;
245 jgs 149 // increment count of arrays dealloced
246 jgs 151 statTable->deallocations++;
247 jgs 121 } else {
248     tab_prev = tab;
249     }
250     tab = tab_next;
251     }
252 jgs 151
253 jgs 121 totalElements -= len;
254    
255 jgs 151 // increment count of elements deallocated
256     statTable->deallocated_elements += len;
257 jgs 149
258 jgs 121 } else {
259     // what to do if no arrays under management?
260     }
261     }
262    
263     int
264     Taipan::num_arrays() {
265    
266     assert(totalElements >= 0);
267    
268     int num_arrays = 0;
269    
270     Taipan_MemTable *tab;
271    
272     // count all managed arrays in the memTable
273     tab = memTable_Root;
274     while (tab != 0) {
275     num_arrays++;
276     tab = tab->next;
277     }
278    
279     return num_arrays;
280     }
281    
282     int
283     Taipan::num_arrays(int N) {
284    
285     assert(totalElements >= 0);
286    
287     int num_arrays = 0;
288    
289     Taipan_MemTable *tab;
290    
291     // count all managed arrays of N blocks in the memTable
292     tab = memTable_Root;
293     while (tab != 0) {
294     if (tab->N == N) {
295     num_arrays++;
296     }
297     tab = tab->next;
298     }
299    
300     return num_arrays;
301     }
302    
303     int
304     Taipan::num_free(int N) {
305    
306     assert(totalElements >= 0);
307    
308     int num_free = 0;
309    
310     Taipan_MemTable *tab;
311    
312     // count all free managed arrays of N blocks in the memTable
313     tab = memTable_Root;
314     while (tab != 0) {
315     if (tab->N == N) {
316     if (tab->free) {
317     num_free++;
318     }
319     }
320     tab = tab->next;
321     }
322     return num_free;
323     }
324    
325     long
326     Taipan::num_elements() {
327 jgs 151
328 jgs 121 assert(totalElements >= 0);
329 jgs 151
330 jgs 121 return totalElements;
331     }
332    
333 jgs 149 void
334     Taipan::dump_stats() {
335 jgs 151
336     assert(totalElements >= 0);
337    
338 phornby 1628 double elMb=statTable->allocated_elements*8.0/1048576;
339     double deelMb=statTable->deallocated_elements*8.0/1048576;
340     double tszMb=statTable->max_tab_size*8.0/1048576;
341 ksteube 1559 #ifdef TAIPAN_STATS
342 gross 798 cout << "======= escript Mem Stats ===========================" << endl;
343 jgs 151 cout << "Total Num requests: " << statTable->requests << endl;
344     cout << "Total Num releases: " << statTable->frees << endl;
345     cout << "Total Num allocated arrays: " << statTable->allocations << endl;
346     cout << "Total Num deallocated arrays: " << statTable->deallocations << endl;
347     cout << "Total Num allocated elements: " << statTable->allocated_elements << " (" << elMb << " Mb)" << endl;
348     cout << "Total Num deallocated elements: " << statTable->deallocated_elements << " (" << deelMb << " Mb)" << endl;
349     cout << "Maximum memory buffer size: " << statTable->max_tab_size << " (" << tszMb << " Mb)" << endl;
350     cout << "Curr Num arrays: " << num_arrays() << endl;
351     cout << "Curr Num elements in buffer: " << num_elements() << endl;
352     cout << "==================================================" << endl;
353 ksteube 1559 #endif
354 jgs 149 }
355    
356     void
357     Taipan::clear_stats() {
358 jgs 151
359     assert(totalElements >= 0);
360    
361     statTable->requests=0;
362     statTable->frees=0;
363     statTable->allocations=0;
364     statTable->deallocations=0;
365     statTable->allocated_elements=0;
366     statTable->deallocated_elements=0;
367     statTable->max_tab_size=0;
368 jgs 149 }
369    
370 jgs 121 } // end of namespace

Properties

Name Value
svn:eol-style native
svn:keywords Author Date Id Revision

  ViewVC Help
Powered by ViewVC 1.1.26