string
gs_system () {
#ifdef OS_MINGW
url gs= url_system ("C:\\") * url_wildcard ("Program Files*") * url_system ("gs") * url_wildcard ("gs*")* url_system ("bin") * url_wildcard ("gswin*c.exe");
return materialize (gs);
#else
return "gs";
#endif
}
WT_Result WT_Font::skip_operand(WT_Opcode const & opcode, WT_File & file)
{
switch (opcode.type())
{
case WT_Opcode::Single_Byte:
{
return materialize(opcode, file);
} break;
case WT_Opcode::Extended_ASCII:
{
WD_CHECK (opcode.skip_past_matching_paren(file));
} break;
case WT_Opcode::Extended_Binary:
default:
return WT_Result::Opcode_Not_Valid_For_This_Object;
} // switch
return WT_Result::Success;
}
void grpc_slice_intern_shutdown(void) {
for (size_t i = 0; i < SHARD_COUNT; i++) {
slice_shard *shard = &g_shards[i];
gpr_mu_destroy(&shard->mu);
/* TODO(ctiller): GPR_ASSERT(shard->count == 0); */
if (shard->count != 0) {
gpr_log(GPR_DEBUG, "WARNING: %" PRIuPTR " metadata strings were leaked",
shard->count);
for (size_t j = 0; j < shard->capacity; j++) {
for (interned_slice_refcount *s = shard->strs[j]; s;
s = s->bucket_next) {
char *text =
grpc_dump_slice(materialize(s), GPR_DUMP_HEX | GPR_DUMP_ASCII);
gpr_log(GPR_DEBUG, "LEAKED: %s", text);
gpr_free(text);
}
}
if (grpc_iomgr_abort_on_leaks()) {
abort();
}
}
gpr_free(shard->strs);
}
}
/**
* Private function to setPosition in a WindowChunk
*/
void WindowChunk::setPosition(WindowArrayIterator const* iterator, Coordinates const& pos)
{
_arrayIterator = iterator;
_firstPos = pos;
Dimensions const& dims = _array._desc.getDimensions();
for (size_t i = 0, n = dims.size(); i < n; i++) {
_lastPos[i] = _firstPos[i] + dims[i].getChunkInterval() - 1;
if (_lastPos[i] > dims[i].getEndMax())
{
_lastPos[i] = dims[i].getEndMax();
}
}
_materialized = false;
if (_aggregate.get() == 0)
{
return;
}
if (_array._desc.getEmptyBitmapAttribute())
{
//
// At this point, we need to make a 1-bit decision about how we
// will compute the window(...) result. Do we materialize all of
// the cells in the inputChunk into a coords -> value map before
// we compute the per-cellwindow aggregate, or do we probe the
// inputChunk's iterator on demand?
//
// The way we figure this out is to (a) compute the total size of
// the materialization by taking at the size of the inputChunk
// (number of elements) and calculating how big the in-memory map
// data structure would be. Then (b) we compare this size to a
// (configurable) threshhold, which is a constant (configurable)
// multiplier of the CONFIG_MEM_ARRAY_THRESHHOLD.
//
// Although using size estimations appears to be a significant
// improvement over using a simple estimate of the sparsity of the
// input, there are several problems with the mechanism
// implemented here.
//
// 1. The calculation of the inputChunk.count() can involve a
// complete iteration through the inputChunk's values, which
// means that we might be computing a sub-query's results
// for the operator twice.
//
// Consider: window ( filter ( A, expr ), ... ).
//
// FIXME: Need to support some kind of cheap and reasonably
// accurate estimate of the size of an operator's
// output chunk, given the size(s) of its input chunk(s).
//
// 2. The real thing we are trying to minimize here is the
// expense of all of the of probe calls to into the inputChunk.
// The total number of probes calls is a product of the input
// size, the number of cells, and the chunk's sparsity. Probing
// (or ideally scanning) a materialized inputChunk is usually
// a lot less expensive than probing an unmaterialized
// inputChunk.
//
// BUT the constant overhead to materialize the inputChunk is
// quite high. So we would probably benefit from a smarter way
// to choose between the two algorithms that incorporated the
// fixed cost.
//
// 3. As input chunk is often going to be ordered, the cost of
// materializing the inputChunk by using a map<> is higher than
// it needs to be. See detailed note in the materialize()
// function.
//
if (_arrayIterator->getMethod() == WindowArray::MATERIALIZE)
{
materialize();
} else if (_arrayIterator->getMethod() != WindowArray::PROBE)
{
//
// The operator has expressed no preference about the
// algorithm. So we figure out whther materializing the source
// involves too much memory.
ConstChunk const& inputChunk = _arrayIterator->iterator->getChunk();
size_t varSize = getAttributeDesc().getVarSize();
if (varSize <= 8)
{
varSize=0;
} else if (varSize ==0)
{
varSize=Config::getInstance()->getOption<int>(CONFIG_STRING_SIZE_ESTIMATION);
}
size_t materializedChunkSize = inputChunk.count() *
( sizeof( _Rb_tree_node_base ) +
sizeof ( scidb::Value ) +
sizeof ( position_t ) +
varSize );
size_t maxMaterializedChunkSize = (
Config::getInstance()->getOption<int>(CONFIG_MATERIALIZED_WINDOW_THRESHOLD)
* MiB); // All config.ini params are in Mebibytes.
if ( materializedChunkSize <= maxMaterializedChunkSize )
{
materialize();
} else {
LOG4CXX_TRACE ( windowLogger,
"WindowChunk::setPosition(..) - NOT MATERIALIZING \n"
<< "\t materializedChunkSize = " << materializedChunkSize
<< " as inputChunk.count() = " << inputChunk.count() << " and varSize = " << varSize
<< " and maxMaterializedChunkSize = " << maxMaterializedChunkSize
);
LOG4CXX_TRACE ( windowLogger, "\t NOT MATERIALIZING ");
}
}
}
}
bool column_major_matrix_table_slice_builder::add(data_view x) {
return append(materialize(x));
}
WT_Result WT_Units::skip_operand(WT_Opcode const & opcode, WT_File & file)
{
return materialize(opcode, file);
}
grpc_slice grpc_slice_intern(grpc_slice slice) {
GPR_TIMER_BEGIN("grpc_slice_intern", 0);
if (GRPC_IS_STATIC_METADATA_STRING(slice)) {
GPR_TIMER_END("grpc_slice_intern", 0);
return slice;
}
uint32_t hash = grpc_slice_hash(slice);
for (uint32_t i = 0; i <= max_static_metadata_hash_probe; i++) {
static_metadata_hash_ent ent =
static_metadata_hash[(hash + i) % GPR_ARRAY_SIZE(static_metadata_hash)];
if (ent.hash == hash && ent.idx < GRPC_STATIC_MDSTR_COUNT &&
grpc_slice_eq(grpc_static_slice_table[ent.idx], slice)) {
GPR_TIMER_END("grpc_slice_intern", 0);
return grpc_static_slice_table[ent.idx];
}
}
interned_slice_refcount *s;
slice_shard *shard = &g_shards[SHARD_IDX(hash)];
gpr_mu_lock(&shard->mu);
/* search for an existing string */
size_t idx = TABLE_IDX(hash, shard->capacity);
for (s = shard->strs[idx]; s; s = s->bucket_next) {
if (s->hash == hash && grpc_slice_eq(slice, materialize(s))) {
if (gpr_atm_no_barrier_fetch_add(&s->refcnt, 1) == 0) {
/* If we get here, we've added a ref to something that was about to
* die - drop it immediately.
* The *only* possible path here (given the shard mutex) should be to
* drop from one ref back to zero - assert that with a CAS */
GPR_ASSERT(gpr_atm_rel_cas(&s->refcnt, 1, 0));
/* and treat this as if we were never here... sshhh */
} else {
gpr_mu_unlock(&shard->mu);
GPR_TIMER_END("grpc_slice_intern", 0);
return materialize(s);
}
}
}
/* not found: create a new string */
/* string data goes after the internal_string header */
s = (interned_slice_refcount *)gpr_malloc(sizeof(*s) +
GRPC_SLICE_LENGTH(slice));
gpr_atm_rel_store(&s->refcnt, 1);
s->length = GRPC_SLICE_LENGTH(slice);
s->hash = hash;
s->base.vtable = &interned_slice_vtable;
s->base.sub_refcount = &s->sub;
s->sub.vtable = &interned_slice_sub_vtable;
s->sub.sub_refcount = &s->sub;
s->bucket_next = shard->strs[idx];
shard->strs[idx] = s;
memcpy(s + 1, GRPC_SLICE_START_PTR(slice), GRPC_SLICE_LENGTH(slice));
shard->count++;
if (shard->count > shard->capacity * 2) {
grow_shard(shard);
}
gpr_mu_unlock(&shard->mu);
GPR_TIMER_END("grpc_slice_intern", 0);
return materialize(s);
}
