escript/src/Taipan.cpp


/* $Id$ */

/*******************************************************
 *
 *           Copyright 2003-2007 by ACceSS MNRF
 *       Copyright 2007 by University of Queensland
 *
 *                http://esscc.uq.edu.au
 *        Primary Business: Queensland, Australia
 *  Licensed under the Open Software License version 3.0
 *     http://www.opensource.org/licenses/osl-3.0.php
 *
 *******************************************************/

#include "Taipan.h"

#include <iostream>
#include <cassert>

#ifdef _OPENMP
#include <omp.h>
#endif

using namespace std;

namespace escript {

Taipan::Taipan() :
  memTable_Root(0),
  totalElements(0)
{
  // create and initialise a new StatTable
  statTable = new Taipan_StatTable;
  clear_stats();
}

Taipan::~Taipan() {

  long len=0;
  Taipan_MemTable *tab;
  Taipan_MemTable *tab_next;

  // dump memory usage statistics
  dump_stats();

  // deallocate StatTable object
  delete statTable;

  // deallocate all managed arrays and the memTable
  tab = memTable_Root;
  while (tab != 0) {
    tab_next = tab->next;
    len = tab->dim * tab->N;
    totalElements -= len;
    delete[] tab->array;
    delete tab;
    tab = tab_next;
  }

  assert(totalElements == 0);

  // clear the MemTable root node
  memTable_Root = 0;

  // reset totalElements counter
  totalElements = -1;
}

void
Taipan::release_unused_arrays()
{
  long len=0;
  Taipan_MemTable *tab;
  Taipan_MemTable *tab_next, *tab_prev=0;
  tab = memTable_Root;
  while (tab != 0) {
      tab_next = tab->next;
      if (tab->free) {
        delete[] tab->array;
        len += tab->dim * tab->N;
        if (tab_prev != 0) {
          tab_prev->next = tab->next;
        } else {
          memTable_Root = tab->next;
        }
        delete tab;
        // increment count of arrays dealloced
        statTable->deallocations++;
      } else {
        tab_prev = tab;
      }
      tab = tab_next;
  }
  totalElements -= len;
  statTable->deallocated_elements += len;
  cout << len*8./1048576 << " Mbytes unused memory has been released." << endl;
}


double*
Taipan::new_array(int dim, int N) {

  assert(totalElements >= 0);

  int len = 0;
  #ifdef _OPENMP
  int numThreads = omp_get_num_threads();
  #else
  int numThreads = 1;
  #endif

  Taipan_MemTable *tab;
  Taipan_MemTable *new_tab;
  Taipan_MemTable *tab_prev;

  // increment count of alloc operations called
  statTable->requests++;

  // is a suitable array already available?
  if (memTable_Root != 0) {
    tab = memTable_Root;
    while (tab != 0) {
      if (tab->dim == dim &&
          tab->N == N &&
          tab->free &&
          tab->numThreads == numThreads) {
        tab->free = false;
        return tab->array;
      }
      tab_prev = tab;
      tab = tab->next;
    }
  }

  // otherwise a new array must be allocated

  // create the corresponding memTable entry
  len = dim * N;
  new_tab = new Taipan_MemTable;
  new_tab->dim = dim;
  new_tab->N = N;
  new_tab->numThreads = numThreads;
  new_tab->free = false;
  new_tab->next = 0;
  if (memTable_Root == 0) {
    memTable_Root = new_tab;
  } else {
    tab_prev->next = new_tab;
  }

  // allocate and initialise the new array
  new_tab->array = new double[len];
  int i,j;
  if (N==1) {
    for (j=0; j<dim; j++) 
      new_tab->array[j]=0.0;
  } else if (N>1) {
    #pragma omp parallel for private(i,j) schedule(static)
    for (i=0; i<N; i++) {
      for (j=0; j<dim; j++) 
        new_tab->array[j+dim*i]=0.0;
    }
  }

  totalElements += len;

  // update maximum table size
  statTable->max_tab_size = (statTable->max_tab_size < totalElements) ? totalElements : statTable->max_tab_size;

  // increment count of arrays allocated
  statTable->allocations++;

  // increment count of elements allocated
  statTable->allocated_elements += len;

  return new_tab->array;
}

void
Taipan::delete_array(double* array) {

  assert(totalElements >= 0);

  int N;
  int len = 0;
  bool found = false;

  Taipan_MemTable *tab;
  Taipan_MemTable *tab_next;
  Taipan_MemTable *tab_prev = 0;

  // increment count of free operations called
  statTable->frees++;

  if (array == 0) {
    // have been given an empty array, so quit now
    return;
  }

  if (memTable_Root != 0) {

    // find the table entry for this array and mark it as free
    tab = memTable_Root;
    while (tab != 0) {
      if (tab->array == array) {
        N = tab->N;
        tab->free = true;
        found = true;
        break;
      }
      tab = tab->next;
    }
    if (!found) {
      // this wasn't an array under management, so quit now
      return;
    }

    if (N<=1) {
      // we never deallocate arrays with N<=1, so quit now
      return;
    }

    // are there any N block arrays still in use?
    tab = memTable_Root;
    while (tab != 0) {
      if (tab->N==N && !tab->free) 
        return;
      tab = tab->next;
    }

    // if not, all N block arrays are deallocated
    tab = memTable_Root;
    while (tab != 0) {
      tab_next = tab->next;
      if (tab->N == N) {
        delete[] tab->array;
        len += tab->dim * N;
        if (tab_prev != 0) {
          tab_prev->next = tab->next;
        } else {
          memTable_Root = tab->next;
        }
        delete tab;
        // increment count of arrays dealloced
        statTable->deallocations++;
      } else {
        tab_prev = tab;
      }
      tab = tab_next;
    }
   
    totalElements -= len;

    // increment count of elements deallocated
    statTable->deallocated_elements += len;

  } else {
    // what to do if no arrays under management?
  }
}

int
Taipan::num_arrays() {

  assert(totalElements >= 0);

  int num_arrays = 0;

  Taipan_MemTable *tab;

  // count all managed arrays in the memTable
  tab = memTable_Root;
  while (tab != 0) {
    num_arrays++;
    tab = tab->next;
  }

  return num_arrays;
}

int
Taipan::num_arrays(int N) {

  assert(totalElements >= 0);

  int num_arrays = 0;

  Taipan_MemTable *tab;

  // count all managed arrays of N blocks in the memTable
  tab = memTable_Root;
  while (tab != 0) {
    if (tab->N == N) {
      num_arrays++;
    }
    tab = tab->next;
  }

  return num_arrays;
}

int
Taipan::num_free(int N) {

  assert(totalElements >= 0);

  int num_free = 0;

  Taipan_MemTable *tab;

  // count all free managed arrays of N blocks in the memTable
  tab = memTable_Root;
  while (tab != 0) {
    if (tab->N == N) {
      if (tab->free) {
        num_free++;
      }
    }
    tab = tab->next;
  }
  return num_free;
}

long
Taipan::num_elements() {

  assert(totalElements >= 0);

  return totalElements;
}

void
Taipan::dump_stats() {

  assert(totalElements >= 0);

  float elMb=statTable->allocated_elements*8.0/1048576;
  float deelMb=statTable->deallocated_elements*8.0/1048576;
  float tszMb=statTable->max_tab_size*8.0/1048576;
#ifdef TAIPAN_STATS
  cout << "======= escript Mem Stats ===========================" << endl;
  cout << "Total Num requests:             " << statTable->requests << endl;
  cout << "Total Num releases:             " << statTable->frees << endl;
  cout << "Total Num allocated arrays:     " << statTable->allocations << endl;
  cout << "Total Num deallocated arrays:   " << statTable->deallocations << endl;
  cout << "Total Num allocated elements:   " << statTable->allocated_elements << " (" << elMb << " Mb)" << endl;
  cout << "Total Num deallocated elements: " << statTable->deallocated_elements << " (" << deelMb << " Mb)" << endl;
  cout << "Maximum memory buffer size:     " << statTable->max_tab_size << " (" << tszMb << " Mb)" << endl;
  cout << "Curr Num arrays:                " << num_arrays() << endl;
  cout << "Curr Num elements in buffer:    " << num_elements() << endl;
  cout << "==================================================" << endl;
#endif
}

void
Taipan::clear_stats() {

  assert(totalElements >= 0);

  statTable->requests=0;
  statTable->frees=0;
  statTable->allocations=0;
  statTable->deallocations=0;
  statTable->allocated_elements=0;
  statTable->deallocated_elements=0;
  statTable->max_tab_size=0;
}

}  // end of namespace
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	ksteube	1312	float elMb=statTable->allocated_elements*8.0/1048576;
339			float deelMb=statTable->deallocated_elements*8.0/1048576;
340			float 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
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision