Ejemplos de validate_cache en C++ (Cpp)

Ejemplo n.º 1

Archivo: cache.cpp Proyecto: delcypher/Halide

WEAK void prune_cache() {
#if CACHE_DEBUGGING
    validate_cache();
#endif
    CacheEntry *prune_candidate = least_recently_used;
    while (current_cache_size > max_cache_size &&
           prune_candidate != NULL) {
        CacheEntry *more_recent = prune_candidate->more_recent;
        
        if (prune_candidate->in_use_count == 0) {
            uint32_t h = prune_candidate->hash;
            uint32_t index = h % kHashTableSize;

            // Remove from hash table
            CacheEntry *prev_hash_entry = cache_entries[index];
            if (prev_hash_entry == prune_candidate) {
                cache_entries[index] = prune_candidate->next;
            } else {
                while (prev_hash_entry != NULL && prev_hash_entry->next != prune_candidate) {
                    prev_hash_entry = prev_hash_entry->next;
                }
                halide_assert(NULL, prev_hash_entry != NULL);
                prev_hash_entry->next = prune_candidate->next;
            }

            // Remove from less recent chain.
            if (least_recently_used == prune_candidate) {
                least_recently_used = more_recent;
            }
            if (more_recent != NULL) {
                more_recent->less_recent = prune_candidate->less_recent;
            }

            // Remove from more recent chain.
            if (most_recently_used == prune_candidate) {
                most_recently_used = prune_candidate->less_recent;
            }
            if (prune_candidate->less_recent != NULL) {
                prune_candidate->less_recent = more_recent;
            }

            // Decrease cache used amount.
            for (int32_t i = 0; i < prune_candidate->tuple_count; i++) {
                current_cache_size -= full_extent(prune_candidate->buffer(i));
            }

            // Deallocate the entry.
            prune_candidate->destroy();
            halide_free(NULL, prune_candidate);
        }

        prune_candidate = more_recent;
    }
#if CACHE_DEBUGGING
    validate_cache();
#endif
}

Ejemplo n.º 2

Archivo: cached_summation.cpp Proyecto: adilevin/parallel_algorithms

int cached_summation_node::get_or_calc_sum()
{
	if (!is_cache_valid()) {
		validate_cache();
		InterlockedExchange(&cached_sum,calc_sum_from_children());
	}
	return cached_sum;
}

Ejemplo n.º 3

Archivo: cache.cpp Proyecto: josephwinston/Halide

WEAK void prune_cache() {
#if CACHE_DEBUGGING
    validate_cache();
#endif
    while (current_cache_size > max_cache_size &&
            least_recently_used != NULL) {
        CacheEntry *lru_entry = least_recently_used;
        uint32_t h = lru_entry->hash;
        uint32_t index = h % kHashTableSize;

        CacheEntry *entry = cache_entries[index];
        if (entry == lru_entry) {
            cache_entries[index] = lru_entry->next;
        } else {
            while (entry != NULL && entry->next != lru_entry) {
                entry = entry->next;
            }
            halide_assert(NULL, entry != NULL);
            entry->next = lru_entry->next;
        }
        least_recently_used = lru_entry->more_recent;
        if (least_recently_used != NULL) {
            least_recently_used->less_recent = NULL;
        }
        if (most_recently_used == lru_entry) {
            most_recently_used = NULL;
        }
        for (int32_t i = 0; i < lru_entry->tuple_count; i++) {
            current_cache_size -= full_extent(lru_entry->buffer(i));
        }

        lru_entry->destroy();
        halide_free(NULL, lru_entry);
    }
#if CACHE_DEBUGGING
    validate_cache();
#endif
}

Ejemplo n.º 4

Archivo: Gtables.c Proyecto: 0-T-0/linux-sgx

HIDDEN int
ia64_local_validate_cache (unw_addr_space_t as, void *arg)
{
  return validate_cache (as);
}