Download third_party/ktx-src/external/basisu/transcoder/basisu_containers_impl.h from kimjunhan/vkgs-sim: direct link, hf CLI and curl.
- Browser
- Download file 8.2 kB
-
https://huggingface.co/kimjunhan/vkgs-sim/resolve/main/third_party/ktx-src/external/basisu/transcoder/basisu_containers_impl.h
- Command line
-
hf download hf://kimjunhan/vkgs-sim/third_party/ktx-src/external/basisu/transcoder/basisu_containers_impl.h
-
curl -L -o basisu_containers_impl.h https://huggingface.co/kimjunhan/vkgs-sim/resolve/main/third_party/ktx-src/external/basisu/transcoder/basisu_containers_impl.h
8.2 kB
| // basisu_containers_impl.h | |
| // Do not include directly | |
| namespace basisu | |
| { | |
| bool elemental_vector::increase_capacity(uint32_t min_new_capacity, bool grow_hint, uint32_t element_size, object_mover pMover, bool nofail) | |
| { | |
| assert(m_size <= m_capacity); | |
| if (sizeof(void *) == sizeof(uint64_t)) | |
| assert(min_new_capacity < (0x400000000ULL / element_size)); | |
| else | |
| assert(min_new_capacity < (0x7FFF0000U / element_size)); | |
| if (m_capacity >= min_new_capacity) | |
| return true; | |
| size_t new_capacity = min_new_capacity; | |
| if ((grow_hint) && (!helpers::is_power_of_2((uint64_t)new_capacity))) | |
| { | |
| new_capacity = (size_t)helpers::next_pow2((uint64_t)new_capacity); | |
| assert(new_capacity && (new_capacity > m_capacity)); | |
| if (new_capacity < min_new_capacity) | |
| { | |
| if (nofail) | |
| return false; | |
| fprintf(stderr, "vector too large\n"); | |
| abort(); | |
| } | |
| } | |
| const size_t desired_size = element_size * new_capacity; | |
| size_t actual_size = 0; | |
| if (!pMover) | |
| { | |
| void* new_p = realloc(m_p, desired_size); | |
| if (!new_p) | |
| { | |
| if (nofail) | |
| return false; | |
| char buf[256]; | |
| sprintf_s(buf, sizeof(buf), "vector: realloc() failed allocating %u bytes", (uint32_t)desired_size); | |
| snprintf(buf, sizeof(buf), "vector: realloc() failed allocating %u bytes", (uint32_t)desired_size); | |
| fprintf(stderr, "%s", buf); | |
| abort(); | |
| } | |
| actual_size = desired_size; | |
| actual_size = _msize(new_p); | |
| actual_size = malloc_usable_size(new_p); | |
| actual_size = desired_size; | |
| m_p = new_p; | |
| } | |
| else | |
| { | |
| void* new_p = malloc(desired_size); | |
| if (!new_p) | |
| { | |
| if (nofail) | |
| return false; | |
| char buf[256]; | |
| sprintf_s(buf, sizeof(buf), "vector: malloc() failed allocating %u bytes", (uint32_t)desired_size); | |
| snprintf(buf, sizeof(buf), "vector: malloc() failed allocating %u bytes", (uint32_t)desired_size); | |
| fprintf(stderr, "%s", buf); | |
| abort(); | |
| } | |
| actual_size = desired_size; | |
| actual_size = _msize(new_p); | |
| actual_size = malloc_usable_size(new_p); | |
| actual_size = desired_size; | |
| (*pMover)(new_p, m_p, m_size); | |
| if (m_p) | |
| free(m_p); | |
| m_p = new_p; | |
| } | |
| if (actual_size > desired_size) | |
| m_capacity = static_cast<uint32_t>(actual_size / element_size); | |
| else | |
| m_capacity = static_cast<uint32_t>(new_capacity); | |
| return true; | |
| } | |
| static void handle_hashmap_test_verify_failure(int line) | |
| { | |
| fprintf(stderr, "HASHMAP_TEST_VERIFY() faild on line %i\n", line); | |
| abort(); | |
| } | |
| class counted_obj | |
| { | |
| public: | |
| counted_obj(uint32_t v = 0) : | |
| m_val(v) | |
| { | |
| m_count++; | |
| } | |
| counted_obj(const counted_obj& obj) : | |
| m_val(obj.m_val) | |
| { | |
| m_count++; | |
| } | |
| ~counted_obj() | |
| { | |
| assert(m_count > 0); | |
| m_count--; | |
| } | |
| static uint32_t m_count; | |
| uint32_t m_val; | |
| operator size_t() const { return m_val; } | |
| bool operator== (const counted_obj& rhs) const { return m_val == rhs.m_val; } | |
| bool operator== (const uint32_t rhs) const { return m_val == rhs; } | |
| }; | |
| uint32_t counted_obj::m_count; | |
| static uint32_t urand32() | |
| { | |
| uint32_t a = rand(); | |
| uint32_t b = rand() << 15; | |
| uint32_t c = rand() << (32 - 15); | |
| return a ^ b ^ c; | |
| } | |
| static int irand32(int l, int h) | |
| { | |
| assert(l < h); | |
| if (l >= h) | |
| return l; | |
| uint32_t range = static_cast<uint32_t>(h - l); | |
| uint32_t rnd = urand32(); | |
| uint32_t rnd_range = static_cast<uint32_t>((((uint64_t)range) * ((uint64_t)rnd)) >> 32U); | |
| int result = l + rnd_range; | |
| assert((result >= l) && (result < h)); | |
| return result; | |
| } | |
| void hash_map_test() | |
| { | |
| { | |
| basisu::hash_map<uint64_t, uint64_t> k; | |
| basisu::hash_map<uint64_t, uint64_t> l; | |
| std::swap(k, l); | |
| k.begin(); | |
| k.end(); | |
| k.clear(); | |
| k.empty(); | |
| k.erase(0); | |
| k.insert(0, 1); | |
| k.find(0); | |
| k.get_equals(); | |
| k.get_hasher(); | |
| k.get_table_size(); | |
| k.reset(); | |
| k.reserve(1); | |
| k = l; | |
| k.set_equals(l.get_equals()); | |
| k.set_hasher(l.get_hasher()); | |
| k.get_table_size(); | |
| } | |
| uint32_t seed = 0; | |
| for (; ; ) | |
| { | |
| seed++; | |
| typedef basisu::hash_map<counted_obj, counted_obj> my_hash_map; | |
| my_hash_map m; | |
| const uint32_t n = irand32(0, 100000); | |
| printf("%u\n", n); | |
| srand(seed); // r1.seed(seed); | |
| basisu::vector<int> q; | |
| uint32_t count = 0; | |
| for (uint32_t i = 0; i < n; i++) | |
| { | |
| uint32_t v = urand32() & 0x7FFFFFFF; | |
| my_hash_map::insert_result res = m.insert(counted_obj(v), counted_obj(v ^ 0xdeadbeef)); | |
| if (res.second) | |
| { | |
| count++; | |
| q.push_back(v); | |
| } | |
| } | |
| HASHMAP_TEST_VERIFY(m.size() == count); | |
| srand(seed); | |
| my_hash_map cm(m); | |
| m.clear(); | |
| m = cm; | |
| cm.reset(); | |
| for (uint32_t i = 0; i < n; i++) | |
| { | |
| uint32_t v = urand32() & 0x7FFFFFFF; | |
| my_hash_map::const_iterator it = m.find(counted_obj(v)); | |
| HASHMAP_TEST_VERIFY(it != m.end()); | |
| HASHMAP_TEST_VERIFY(it->first == v); | |
| HASHMAP_TEST_VERIFY(it->second == (v ^ 0xdeadbeef)); | |
| } | |
| for (uint32_t t = 0; t < 2; t++) | |
| { | |
| const uint32_t nd = irand32(1, q.size() + 1); | |
| for (uint32_t i = 0; i < nd; i++) | |
| { | |
| uint32_t p = irand32(0, q.size()); | |
| int k = q[p]; | |
| if (k >= 0) | |
| { | |
| q[p] = -k - 1; | |
| bool s = m.erase(counted_obj(k)); | |
| HASHMAP_TEST_VERIFY(s); | |
| } | |
| } | |
| typedef basisu::hash_map<uint32_t, empty_type> uint_hash_set; | |
| uint_hash_set s; | |
| for (uint32_t i = 0; i < q.size(); i++) | |
| { | |
| int v = q[i]; | |
| if (v >= 0) | |
| { | |
| my_hash_map::const_iterator it = m.find(counted_obj(v)); | |
| HASHMAP_TEST_VERIFY(it != m.end()); | |
| HASHMAP_TEST_VERIFY(it->first == (uint32_t)v); | |
| HASHMAP_TEST_VERIFY(it->second == ((uint32_t)v ^ 0xdeadbeef)); | |
| s.insert(v); | |
| } | |
| else | |
| { | |
| my_hash_map::const_iterator it = m.find(counted_obj(-v - 1)); | |
| HASHMAP_TEST_VERIFY(it == m.end()); | |
| } | |
| } | |
| uint32_t found_count = 0; | |
| for (my_hash_map::const_iterator it = m.begin(); it != m.end(); ++it) | |
| { | |
| HASHMAP_TEST_VERIFY(it->second == ((uint32_t)it->first ^ 0xdeadbeef)); | |
| uint_hash_set::const_iterator fit(s.find((uint32_t)it->first)); | |
| HASHMAP_TEST_VERIFY(fit != s.end()); | |
| HASHMAP_TEST_VERIFY(fit->first == it->first); | |
| found_count++; | |
| } | |
| HASHMAP_TEST_VERIFY(found_count == s.size()); | |
| } | |
| HASHMAP_TEST_VERIFY(counted_obj::m_count == m.size() * 2); | |
| } | |
| } | |
| } // namespace basisu | |