← Back to branch summary

~ubuntu-branches/ubuntu/trusty/nwchem/trusty-proposed

« back to all changes in this revision

Viewing changes to src/tools/ga-5-1/ma/table.c

  • Committer: Package Import Robot
  • Author(s): Michael Banck, Daniel Leidert, Andreas Tille, Michael Banck
  • Date: 2013-07-04 12:14:55 UTC
  • mfrom: (1.1.2)
  • Revision ID: package-import@ubuntu.com-20130704121455-5tvsx2qabor3nrui
Tags: 6.3-1
http://bugs.debian.org/696361
* New upstream release.
* Fixes anisotropic properties (Closes: #696361).
* New features include:
  + Multi-reference coupled cluster (MRCC) approaches
  + Hybrid DFT calculations with short-range HF 
  + New density-functionals including Minnesota (M08, M11) and HSE hybrid
    functionals
  + X-ray absorption spectroscopy (XAS) with TDDFT
  + Analytical gradients for the COSMO solvation model
  + Transition densities from TDDFT 
  + DFT+U and Electron-Transfer (ET) methods for plane wave calculations
  + Exploitation of space group symmetry in plane wave geometry optimizations
  + Local density of states (LDOS) collective variable added to Metadynamics
  + Various new XC functionals added for plane wave calculations, including
    hybrid and range-corrected ones
  + Electric field gradients with relativistic corrections 
  + Nudged Elastic Band optimization method
  + Updated basis sets and ECPs 

[ Daniel Leidert ]
* debian/watch: Fixed.

[ Andreas Tille ]
* debian/upstream: References

[ Michael Banck ]
* debian/upstream (Name): New field.
* debian/patches/02_makefile_flags.patch: Refreshed.
* debian/patches/06_statfs_kfreebsd.patch: Likewise.
* debian/patches/07_ga_target_force_linux.patch: Likewise.
* debian/patches/05_avoid_inline_assembler.patch: Removed, no longer needed.
* debian/patches/09_backported_6.1.1_fixes.patch: Likewise.
* debian/control (Build-Depends): Added gfortran-4.7 and gcc-4.7.
* debian/patches/10_force_gcc-4.7.patch: New patch, explicitly sets
  gfortran-4.7 and gcc-4.7, fixes test suite hang with gcc-4.8 (Closes:
  #701328, #713262).
* debian/testsuite: Added tests for COSMO analytical gradients and MRCC.
* debian/rules (MRCC_METHODS): New variable, required to enable MRCC methods.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/tools/ga-5-1/ma/table.c
1
 
#if HAVE_CONFIG_H
2
 
#   include "config.h"
3
 
#endif
4
 
 
5
 
/*
6
 
 * $Id: table.c,v 1.6 2000-10-13 23:18:18 d3h325 Exp $
7
 
 */
8
 
 
9
 
/*
10
 
 * Dynamic table module.
11
 
 *
12
 
 * Each table entry consists of an external data item and internal state.
13
 
 * The size of the table is automatically increased if there isn't room
14
 
 * to add another entry.  The client can allocate, deallocate, verify
15
 
 * entries, and perform both handle-->data and data-->handle lookup.
16
 
 */
17
 
 
18
 
#if HAVE_STDIO_H
19
 
#   include <stdio.h>
20
 
#endif
21
 
#if HAVE_STDLIB_H
22
 
#   include <stdlib.h>
23
 
#endif
24
 
#include "error.h"
25
 
#include "memcpy.h"
26
 
#include "scope.h"
27
 
#include "table.h"
28
 
 
29
 
/**
30
 
 ** constants
31
 
 **/
32
 
 
33
 
/* default # of initial table entries */
34
 
#define DEFAULT_TABLE_ENTRIES    32
35
 
 
36
 
/**
37
 
 ** types
38
 
 **/
39
 
 
40
 
/* state of a TableEntry */
41
 
typedef enum
42
 
{
43
 
    TES_Unused = 0,            /* never used */
44
 
    TES_Allocated,            /* currently in use */
45
 
    TES_Deallocated            /* formerly in use */
46
 
} TableEntryState;
47
 
 
48
 
/* table entry consists of data and state */
49
 
typedef struct _TableEntry
50
 
{
51
 
    TableData        data;        /* in this entry */
52
 
    TableEntryState    state;        /* of this entry */
53
 
} TableEntry;
54
 
 
55
 
/* table is an array of table entries */
56
 
typedef TableEntry * Table;
57
 
 
58
 
/**
59
 
 ** variables
60
 
 **/
61
 
 
62
 
/* currently only one table is managed */
63
 
private Table ma_table = NULL;
64
 
 
65
 
private Integer ma_table_capacity = 0;
66
 
private Integer ma_table_entries = 0;
67
 
private Integer ma_table_next_slot = 0;
68
 
 
69
 
/**
70
 
 ** public routines for internal use only
71
 
 **/
72
 
 
73
 
/* ------------------------------------------------------------------------- */
74
 
/*
75
 
 * Allocate a table slot, store the given data into it, and return a handle
76
 
 * by which the slot may be referenced.  If a slot cannot be allocated,
77
 
 * return TABLE_HANDLE_NONE.
78
 
 */
79
 
/* ------------------------------------------------------------------------- */
80
 
 
81
 
public Integer ma_table_allocate(data)
82
 
    TableData    data;        /* to store */
83
 
{
84
 
    Table    new_ma_table;
85
 
    Integer    new_ma_table_capacity;
86
 
    unsigned    new_ma_table_size;
87
 
    Integer    i;
88
 
    Integer    slots_examined;
89
 
 
90
 
    /* expand the table if necessary */
91
 
    if (ma_table_entries >= ma_table_capacity)
92
 
    {
93
 
        /* increase table capacity */
94
 
        if (ma_table_capacity == 0)
95
 
            /* set the initial capacity */
96
 
            new_ma_table_capacity = DEFAULT_TABLE_ENTRIES;
97
 
        else
98
 
            /* double the current capacity */
99
 
            new_ma_table_capacity = 2 * ma_table_capacity;
100
 
 
101
 
        /* allocate space for new table */
102
 
        new_ma_table_size = (unsigned)(new_ma_table_capacity * sizeof(TableEntry));
103
 
        if ((new_ma_table = (Table)bytealloc(new_ma_table_size)) == (Table)NULL)
104
 
        {
105
 
            (void)sprintf(ma_ebuf,
106
 
                "could not allocate %u bytes for ma_table",
107
 
                new_ma_table_size);
108
 
            ma_error(EL_Nonfatal, ET_Internal, "ma_table_allocate", ma_ebuf);
109
 
            return TABLE_HANDLE_NONE;
110
 
        }
111
 
 
112
 
        /* copy and free old table */
113
 
        if (ma_table_capacity > 0)
114
 
        {
115
 
            bytecopy(ma_table, new_ma_table, (ma_table_capacity * sizeof(TableEntry)));
116
 
            bytefree(ma_table);
117
 
        }
118
 
 
119
 
        /* initialize new part of new table */
120
 
        for (i = new_ma_table_capacity-1; i >= ma_table_capacity; i--)
121
 
            new_ma_table[i].state = TES_Unused;
122
 
 
123
 
        /* remember the new table */
124
 
        ma_table = new_ma_table;
125
 
        ma_table_next_slot = ma_table_capacity;
126
 
        ma_table_capacity = new_ma_table_capacity;
127
 
    }
128
 
 
129
 
    /* perform a linear circular search to find the next available slot */
130
 
    for (slots_examined = 0, i = ma_table_next_slot;
131
 
         slots_examined < ma_table_capacity;
132
 
         slots_examined++, i = (i+1) % ma_table_capacity)
133
 
    {
134
 
        if (ma_table[i].state != TES_Allocated)
135
 
        {
136
 
            /* store the data */
137
 
            ma_table[i].data = data;
138
 
            ma_table[i].state = TES_Allocated;
139
 
 
140
 
            /* increment ma_table_entries */
141
 
            ma_table_entries++;
142
 
 
143
 
            /* advance ma_table_next_slot */
144
 
            ma_table_next_slot = (i+1) % ma_table_capacity;
145
 
 
146
 
            /* return the handle */
147
 
            return i;
148
 
        }
149
 
    }
150
 
 
151
 
    /* if we get here, something is wrong */
152
 
    (void)sprintf(ma_ebuf,
153
 
        "no ma_table slot available, %ld/%ld slots used",
154
 
        (long)ma_table_entries, (long)ma_table_capacity);
155
 
    ma_error(EL_Nonfatal, ET_Internal, "ma_table_allocate", ma_ebuf);
156
 
    return TABLE_HANDLE_NONE;
157
 
}
158
 
 
159
 
/* ------------------------------------------------------------------------- */
160
 
/*
161
 
 * Deallocate the table slot corresponding to the given handle,
162
 
 * which should have been verified previously (e.g., via ma_table_verify()).
163
 
 * If handle is invalid, print an error message.
164
 
 */
165
 
/* ------------------------------------------------------------------------- */
166
 
 
167
 
public void ma_table_deallocate(handle)
168
 
    Integer    handle;        /* to deallocate */
169
 
{
170
 
    if (ma_table_verify(handle, "ma_table_deallocate"))
171
 
    {
172
 
        /* deallocate the slot */
173
 
        ma_table[handle].state = TES_Deallocated;
174
 
 
175
 
        /* decrement ma_table_entries */
176
 
        ma_table_entries--;
177
 
    }
178
 
}
179
 
 
180
 
/* ------------------------------------------------------------------------- */
181
 
/*
182
 
 * Return the data in the table slot corresponding to the given handle,
183
 
 * which should have been verified previously (e.g., via ma_table_verify()).
184
 
 * If handle is invalid, print an error message and return NULL.
185
 
 */
186
 
/* ------------------------------------------------------------------------- */
187
 
 
188
 
public TableData ma_table_lookup(handle)
189
 
    Integer    handle;        /* to lookup */
190
 
{
191
 
    if (ma_table_verify(handle, "ma_table_lookup"))
192
 
        /* success */
193
 
        return ma_table[handle].data;
194
 
    else
195
 
        /* failure */
196
 
        return (TableData)NULL;
197
 
}
198
 
 
199
 
/* ------------------------------------------------------------------------- */
200
 
/*
201
 
 * Return the handle for the table slot containing the given data (i.e.,
202
 
 * perform an associative or inverted lookup), or TABLE_HANDLE_NONE if
203
 
 * no currently allocated table slot contains the given data.
204
 
 *
205
 
 * If more than one table slot contains the given data, the one whose
206
 
 * handle is returned is undefined (i.e., implementation dependent).
207
 
 */
208
 
/* ------------------------------------------------------------------------- */
209
 
 
210
 
public Integer ma_table_lookup_assoc(data)
211
 
    TableData    data;        /* to lookup */
212
 
{
213
 
    Integer    i;
214
 
 
215
 
    /* perform a linear search from the first table slot */
216
 
    for (i = 0; i < ma_table_capacity; i++)
217
 
        if ((ma_table[i].state == TES_Allocated) && (ma_table[i].data == data))
218
 
            /* success */
219
 
            return i;
220
 
 
221
 
    /* failure */
222
 
    return TABLE_HANDLE_NONE;
223
 
}
224
 
 
225
 
/* ------------------------------------------------------------------------- */
226
 
/*
227
 
 * Return MA_TRUE if the given handle corresponds to a valid table slot
228
 
 * (one that is currently allocated), else return MA_FALSE and print an
229
 
 * error message.
230
 
 */
231
 
/* ------------------------------------------------------------------------- */
232
 
 
233
 
public Boolean ma_table_verify(handle, caller)
234
 
    Integer    handle;        /* to verify */
235
 
    char    *caller;    /* name of calling routine */
236
 
{
237
 
    Boolean    badhandle;    /* is handle invalid? */
238
 
 
239
 
    badhandle = MA_FALSE;
240
 
 
241
 
    /* if handle is invalid, construct an error message */
242
 
    if ((handle < 0) ||
243
 
        (handle >= ma_table_capacity) ||
244
 
        (ma_table[handle].state == TES_Unused))
245
 
    {
246
 
        (void)sprintf(ma_ebuf,
247
 
            "handle %ld is not valid",
248
 
            (long)handle);
249
 
        badhandle = MA_TRUE;
250
 
    }
251
 
    else if (ma_table[handle].state == TES_Deallocated)
252
 
    {
253
 
        (void)sprintf(ma_ebuf,
254
 
            "handle %ld already deallocated",
255
 
            (long)handle);
256
 
        badhandle = MA_TRUE;
257
 
    }
258
 
 
259
 
    if (badhandle)
260
 
    {
261
 
        /* invalid handle */
262
 
        ma_error(EL_Nonfatal, ET_External, caller, ma_ebuf);
263
 
        return MA_FALSE;
264
 
    }
265
 
    else
266
 
        /* valid handle */
267
 
        return MA_TRUE;
268
 
}