int read_wgdos_bitmaps(
/* IN */
char** data, /* PP field to read from */
int ncols, /* Number of elements in row, >=0 */
Boolean missing_data_present, /* Is missing data bitmap present? */
Boolean zeros_bitmap_present, /* Is zeros bitmap present? */
/* IN - Workspace supplied by caller */
void *buffer, /* Buffer at least 2*ncols bits, rounded */
/* up to the next complete int, long */
/* OUT */
Boolean *missing_data, /* Missing data bitmap for row */
Boolean *zero, /* Zeros bitmap for row */
int *missing_data_count, /* Num TRUE elements in missing_data,>=0 */
int *zeros_count /* Num TRUE elements in zero, >=0 */
)
{
int nsus_to_read; /* Number of numeric storage units occupied */
/* by bitmaps */
int zeros_start_bit; /* Bit number in buffer where zeros bitmap starts */
/* Determine length of bitmaps in numeric storage units */
nsus_to_read = (ncols*(missing_data_present + zeros_bitmap_present)+ PP_BITS_PER_NUMERIC - 1) / PP_BITS_PER_NUMERIC;
if ( nsus_to_read > 0 ) {
/* Read bitmaps */
buffer = *data;
*data = *data + sizeof(int)*nsus_to_read;
}
/* Unpack missing data bitmap */
if ( missing_data_present ) {
extract_bitmaps(buffer, 0, ncols, TRUE, missing_data);
COUNTER(*missing_data_count, missing_data, ncols);
} else {
SET_FALSE(missing_data, ncols);
*missing_data_count = 0;
}
/* Unpack zeros bitmap */
if ( zeros_bitmap_present ) {
zeros_start_bit = (missing_data_present ? ncols : 0);
extract_bitmaps(buffer, zeros_start_bit, ncols, FALSE, zero);
COUNTER(*zeros_count, zero, ncols);
} else {
SET_FALSE(zero, ncols);
*zeros_count = 0;
}
return 0;
}
/*
* Exact matches can use bsearch.
*/
int
blist_match(BLIST * data, const char *name)
{
int rc = -1;
int last = blist_count(data);
void *check;
ToFind dummy;
dummy.name = name;
check = bsearch(&dummy, data->theList, (size_t) last, data->itemSize, exact_match);
if (check != 0) {
rc = (int) ItemToInx(data, check);
}
COUNTER(total_linear, rc + 1);
COUNTER(total_limits, last);
COUNTER(total_calls, 1);
return rc;
}
void pa_aupdate_read_end(pa_aupdate *a) {
unsigned PA_UNUSED n;
pa_assert(a);
/* Decrease the lock counter */
n = (unsigned) pa_atomic_dec(&a->read_lock);
/* Make sure the counter was valid */
pa_assert(COUNTER(n) > 0);
/* Post the semaphore */
pa_semaphore_post(a->semaphore);
}
unsigned pa_aupdate_read_begin(pa_aupdate *a) {
unsigned n;
pa_assert(a);
/* Increase the lock counter */
n = (unsigned) pa_atomic_inc(&a->read_lock);
/* When n is 0 we have about 2^31 threads running that all try to
* access the data at the same time, oh my! */
pa_assert(COUNTER(n)+1 > 0);
/* The uppermost bit tells us which data to look at */
return WHICH(n);
}
int main()
{
int temp = 0;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
temp = COUNTER();
std::cout << "第" << temp << "次调用" << std::endl;
return 0;
}
unsigned pa_aupdate_write_swap(pa_aupdate *a) {
unsigned n;
pa_assert(a);
for (;;) {
n = (unsigned) pa_atomic_load(&a->read_lock);
/* If the read counter is > 0 wait; if it is 0 try to swap the lists */
if (COUNTER(n) > 0)
pa_semaphore_wait(a->semaphore);
else if (pa_atomic_cmpxchg(&a->read_lock, (int) n, (int) (n ^ MSB)))
break;
}
a->swapped = true;
return WHICH(n);
}
/*
* Given what may be part of the name (length in 'len'), look for a match.
* If the result is ambiguous, do not match unless the given name exactly
* matches one item.
*/
int
blist_pmatch(BLIST * data, const char *name, int len)
{
int actual = (int) strlen(name);
int rc = -1;
int hi, lo, x0, x1, cmp;
int last = blist_count(data);
const char *item;
const char *test;
if (len < 0 || len > actual)
len = actual;
x1 = -1;
hi = last - 1;
lo = 0;
do {
x0 = x1;
x1 = lo + (hi - lo) / 2;
if (x0 == x1) {
if (++x1 > hi)
break;
}
item = ItemOf(data, x1);
cmp = strncmp(item, name, (size_t) len);
if (cmp < 0) {
lo = (x1 == lo) ? (x1 + 1) : x1;
} else if (cmp > 0) {
hi = (x1 == hi) ? (x1 - 1) : x1;
} else {
rc = x1;
/*
* Check for an exact match...
*/
COUNTER(total_compares, 1);
if (strcmp(item, name)) {
if (x1 > lo) {
ToFind dummy;
dummy.name = name;
test = (const char *) bsearch(&dummy,
&ItemOf(data, lo),
(size_t) (x1 + 1 - lo),
(size_t) data->itemSize,
exact_match);
if (test) {
rc = (int) ItemToInx(data, test);
break;
}
}
}
/*
* Now - if we have not found an exact match, check for ambiguity.
*/
if (rc >= 0) {
if (len > (int) strlen(item)) {
rc = -1;
} else if (x1 < last - 1) {
COUNTER(total_compares, 2);
if (strcmp(item, name)
&& !strncmp(ItemOf(data, x1 + 1), name, (size_t) len)) {
rc = -1;
}
}
}
break;
}
} while (hi >= lo);
COUNTER(total_linear, rc + 2);
COUNTER(total_limits, last);
COUNTER(total_calls, 1);
return rc;
}
static int
exact_match(const void *keyobj, const void *arraymember)
{
COUNTER(total_compares, 1);
return strcmp(*(const char *const *) keyobj, (*(const char *const *) arraymember));
}
