러스트가 개떡같은 EU

프로그래밍 갤러리

자동 짤방 이미지

이미지가 없습니다.

자동 짤방으로 사용할 이미지를 등록해 주세요.

1/3

한국에서 우산을 15개 넘게 샀다는 호주 누나ㄷ 구너
한베 국결 맞선현장..수줍어하는 베트남 신부 배터리형
방굴라대시이읍니다,,,, 쿠루루
오빠 우리집 비는데 치킨 먹고 갈래?.jpg ㅇㅇ
정치적 발언 절대 안하던 메릴스트립이 시상식에서 일갈한 이유.jpg ㅇㅇ
싱글벙글 가장 무서운 계단 top9 Chart_Manager
올해 KIBEX 맥주박람회 참가후기 밤은짧고목표는
WWE 영원한 레전드 헐크 호건 사망 ㅇㅇ
일본車 관세 15%에 미국車 역차별 논란…750조 투자도 미지수 ㅇㅇ
몬서운이야기) 몬헌 역대 온라인 사건들 2편 제가다생각이있
1998년 굴 떼죽음 사건 ㅇㅇ
잠실 짱큰 도로롱 후기 및 즐기고온거 핑핑이는마오마
개빡치는 제미나이 콩국수 ㅇㅇ
10년대 초반, 서구권 드라마에서 묘사된 우리나라 모습들.jpg ㅇㅇ
그 와중에 카카페 신작 하나 여초에서 고로시당했네 ㅇㅇ

실시간으로 불타고 있는 러브라이브 성우 작성자 : ㅇㅇ

나르시

2025.07.23 14:59:03

조회 27 추천 0 댓글 0

러스트로는 이런거 못 짠다.

ㅋㅋㅋ

/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 2; tab-width: 2 -*- */

c-hash-map.c

Unauthorized copying of this software, via any medium is strictly prohibited.

Proprietary and confidential.

Written by Hodong Kim <hodong@nimfsoft.art>

#if defined(__FreeBSD__) || defined(__OpenBSD__)

#include <sys/endian.h>

#else

#define _DEFAULT_SOURCE

#include <endian.h>

#include <sys/random.h>

#endif

#include "c-hash-map.h"

#include <stdlib.h>

#include <string.h>

#include "c-array.h"

#include "c-mem.h"

#include "c-list.h"

/*****************************************************************************/

typedef struct _CEntry CEntry;

struct _CEntry {

CEntry* next;

CEntry* prev;

void* key;

void* value;

};

static CEntry* c_entry_new (void* key, void* value)

{

CEntry* entry = c_malloc (sizeof (CEntry));

entry->key = key;

entry->value = value;

return entry;

}

static void c_entry_free (CEntry* entry,

CFreeFunc key_free_func,

CFreeFunc value_free_func)

{

if (key_free_func)

key_free_func (entry->key);

if (value_free_func)

value_free_func (entry->value);

free (entry);

}

/*****************************************************************************/

uint32_t c_murmur3_32 (const uint8_t* key, size_t len, uint32_t seed)

{

uint32_t h = seed;

uint32_t k;

for (size_t i = len >> 2; i; i--)

{

k = htole32 (*(uint32_t*) key);

key += sizeof (uint32_t);

k *= 0xcc9e2d51;

k = (k << 15) | (k >> 17);

k *= 0x1b873593;

h ^= k;

h = (h << 13) | (h >> 19);

h = h * 5 + 0xe6546b64;

}

k = 0;

for (size_t i = len & 3; i; i--)

{

k <<= 8;

k |= key[i - 1];

}

k *= 0xcc9e2d51;

k = (k << 15) | (k >> 17);

k *= 0x1b873593;

h ^= k;

h ^= len;

h ^= h >> 16;

h *= 0x85ebca6b;

h ^= h >> 13;

h *= 0xc2b2ae35;

h ^= h >> 16;

return h;

}

uintptr_t c_str_hash (const void* str, uint32_t seed)

{

return c_murmur3_32 (str, strlen (str), seed);

}

/*****************************************************************************/

// RAND_MAX: 0x7fffffffU This is a prime number

// UINT32_MAX: 0xffffffffU

#if defined(__FreeBSD__) || defined(__OpenBSD__) || defined(__linux__)

#define PRIME 0xfffffffbU /* for arc4random_uniform() or getrandom() */

#else

#define PRIME 0x7fffffffU /* for rand() */

#endif

typedef struct _CBucket CBucket;

struct _CBucket {

unsigned random; // 1 <= k <= prime - 1

unsigned entries_len; // entries_len = 2 * m * (m - 1)

unsigned m; // entries_len = 2 * m * (m - 1)

unsigned b; // rehash: b = lists[i]->len, insert: b = b + 1

CEntry** entries;

};

// constant

#define DYNFECT_C 1 // m = (1 + c) * C_MAX (count, 4) in rehash()

#define DYNFECT_S 1 // buckets_len = S(M) = DYNFECT_S * dynfect->m

typedef struct _CDynfect CDynfect;

struct _CDynfect {

unsigned random; /* 1 <= k <= prime - 1 */

unsigned buckets_len; /* buckets_len = S(M) = DYNFECT_S * dynfect->m */

CHashFunc key_hash_func;

CEqualFunc key_equal_func;

CFreeFunc key_free_func;

CFreeFunc value_free_func;

CList* list;

CBucket* buckets;

unsigned op_count; /* count++ when add, remove */

unsigned m; /* m = (1 + c) * C_MAX (count, 4) in rehash() */

};

static unsigned c_dynfect_gen_random ()

{

#if !defined(__FreeBSD__) && !defined(__OpenBSD__) && !defined(__linux__)

#if RAND_MAX != 0x7fffffffU

#error "Debug this source code"

#endif

static unsigned seed;

if (!seed)

{

/* This is insecure */

seed = time (NULL);

srand (seed);

}

#endif

/* h(x) = (kx mod p) mod s; 1 <= k <= prime - 1 */

#if defined(__FreeBSD__) || defined(__OpenBSD__)

return arc4random_uniform (PRIME - 1) + 1; /* uint32_t */

#elif defined __linux__

uint32_t buf;

if (getrandom (&buf, sizeof (uint32_t), 0) != -1)

return buf % (PRIME - 1) + 1;

else

return rand() % (PRIME - 1) + 1; /* int */

#else

return rand() % (PRIME - 1) + 1; /* int */

#endif

}

uintptr_t c_ptr_hash (const void* p, uint32_t seed)

{

return (seed * (uintptr_t) p) % PRIME;

}

bool c_ptr_equal (const void* a, const void* b)

{

return a == b;

}

static bool c_dynfect_condition (CDynfect* dynfect)

{

unsigned sum = 0;

// 32 * M * M / S(M) + 4 * M

// S(M) is buckets_len

// buckets_len is DYNFECT_S * dynfect->m

unsigned bound = 32 * dynfect->m / DYNFECT_S + 4 * dynfect->m;

for (unsigned i = 0; i < dynfect->buckets_len; i++)

{

sum = sum + dynfect->buckets[i].m;

if (sum > bound)

return false;

}

return true;

}

static bool c_dynfect_inject (CDynfect* dynfect, CArray* list, CBucket* bucket)

{

bucket->random = c_dynfect_gen_random ();

for (unsigned i = 0; i < list->len; i++)

{

CEntry* entry = list->data[i];

unsigned index = dynfect->key_hash_func (entry->key, bucket->random) %

(unsigned long) bucket->entries_len;

if (bucket->entries[index])

return false;

bucket->entries[index] = entry;

}

return true;

}

static bool c_dynfect_contains (CDynfect* dynfect, const void* key)

{

unsigned i = dynfect->key_hash_func (key, dynfect->random) % (unsigned long) dynfect->buckets_len;

CBucket* bucket = &dynfect->buckets[i];

if (bucket->entries_len > 0)

{

int pos = dynfect->key_hash_func (key, bucket->random) % (unsigned long) bucket->entries_len;

CEntry* entry = bucket->entries[pos];

if (entry && dynfect->key_equal_func (entry->key, key))

return true;

}

return false;

}

static void c_dynfect_rehash (CDynfect* dynfect, CEntry* new_entry)

{

CArray* list;

CArray** lists;

list = c_array_new (NULL, true);

for (unsigned i = 0; i < dynfect->buckets_len; i++)

{

CBucket* bucket = &dynfect->buckets[i];

for (unsigned j = 0; j < bucket->entries_len; j++)

if (bucket->entries[j])

c_array_add (list, bucket->entries[j]);

free (bucket->entries);

}

if (new_entry)

c_array_add (list, new_entry);

dynfect->op_count = list->len;

dynfect->m = (1 + DYNFECT_C) * C_MAX (dynfect->op_count, 4);

dynfect->buckets_len = DYNFECT_S * dynfect->m;

dynfect->buckets = c_realloc (dynfect->buckets,

dynfect->buckets_len * sizeof (CBucket));

memset (dynfect->buckets, 0, dynfect->buckets_len * sizeof (CBucket));

lists = c_calloc (dynfect->buckets_len, sizeof (CArray*));

do {

dynfect->random = c_dynfect_gen_random ();

for (unsigned i = 0; i < dynfect->buckets_len; i++)

if (lists[i] && lists[i]->len)

c_array_clear (lists[i]);

for (unsigned i = 0; i < list->len; i++)

{

CEntry* entry = list->data[i];

unsigned pos = dynfect->key_hash_func (entry->key, dynfect->random) % (unsigned long) dynfect->buckets_len;

if (!lists[pos])

lists[pos] = c_array_new (NULL, true);

c_array_add (lists[pos], entry);

}

for (unsigned i = 0; i < dynfect->buckets_len; i++)

{

CBucket* bucket = &dynfect->buckets[i];

memset (bucket, 0, sizeof (CBucket));

bucket->b = lists[i] ? lists[i]->len : 0;

bucket->m = 2 * bucket->b;

bucket->entries_len = 2 * bucket->m * (bucket->m - 1);

}

} while (!c_dynfect_condition (dynfect));

c_array_free (list);

for (unsigned i = 0; i < dynfect->buckets_len; i++)

{

CBucket* bucket = &dynfect->buckets[i];

if (lists[i] && (lists[i]->len > 0))

{

bucket->entries = c_calloc (bucket->entries_len, sizeof (CEntry*));

do {

memset (bucket->entries, 0, bucket->entries_len * sizeof (CEntry*));

} while (!c_dynfect_inject (dynfect, lists[i], bucket));

}

if (lists[i])

c_array_free (lists[i]);

}

free (lists);

}

static CDynfect* c_dynfect_new (CHashFunc key_hash_func,

CEqualFunc key_equal_func,

CFreeFunc key_free_func,

CFreeFunc value_free_func,

CList* list)

{

CDynfect* dynfect = c_malloc (sizeof (CDynfect));

dynfect->key_hash_func = key_hash_func;

dynfect->key_equal_func = key_equal_func;

dynfect->key_free_func = key_free_func;

dynfect->value_free_func = value_free_func;

dynfect->list = list;

dynfect->op_count = 0;

dynfect->buckets_len = 0;

dynfect->buckets = NULL;

dynfect->m = 0;

c_dynfect_rehash (dynfect, NULL);

return dynfect;

}

static bool

c_dynfect_insert (CDynfect* dynfect, void* key, void* value, CEntry* new_entry)

{

if (new_entry)

key = new_entry->key;

unsigned index = dynfect->key_hash_func (key, dynfect->random) %

(unsigned long) dynfect->buckets_len;

CBucket* bucket = &dynfect->buckets[index];

unsigned pos = 0; // avoid maybe-uninitialized

if (bucket->entries_len > 0)

{

pos = dynfect->key_hash_func (key, bucket->random) %

(unsigned long) bucket->entries_len;

CEntry* entry = bucket->entries[pos];

if (entry)

{

if (dynfect->key_equal_func (entry->key, key))

{

if (dynfect->key_free_func)

dynfect->key_free_func (entry->key);

if (dynfect->value_free_func)

dynfect->value_free_func (entry->value);

entry->key = key;

entry->value = value;

return false;

}

if (!new_entry)

{

new_entry = c_entry_new (key, value);

c_list_insert_end (dynfect->list, (CNode*) new_entry);

}

dynfect->op_count++;

if (dynfect->op_count > dynfect->m)

{

c_dynfect_rehash (dynfect, new_entry);

return true;

}

bucket->b++;

if (bucket->b <= bucket->m)

{

/* bucket->entries_len > 0 is true, so 'pos' NOT maybe-uninitialized */

if (!bucket->entries[pos])

{

bucket->entries[pos] = new_entry;

}

else

{

CArray* list;

list = c_array_new (NULL, true);

for (unsigned i = 0; i < bucket->entries_len; i++)

if (bucket->entries[i])

c_array_add (list, bucket->entries[i]);

c_array_add (list, new_entry);

do {

if (bucket->entries == NULL)

bucket->entries = c_calloc (bucket->entries_len, sizeof (CEntry*));

else

memset (bucket->entries,

0, bucket->entries_len * sizeof (CEntry*));

} while (!c_dynfect_inject (dynfect, list, bucket));

c_array_free (list);

}

else

{

if (c_dynfect_condition (dynfect))

{

CArray* list;

list = c_array_new (NULL, true);

if (bucket->entries)

for (unsigned j = 0; j < bucket->entries_len; j++)

if (bucket->entries[j])

c_array_add (list, bucket->entries[j]);

c_array_add (list, new_entry);

bucket->m = 2 * C_MAX (bucket->m, 1);

bucket->entries_len = 2 * (bucket->m) * (bucket->m - 1);

bucket->entries = c_realloc (bucket->entries,

bucket->entries_len * sizeof (CEntry*));

do {

memset (bucket->entries, 0, bucket->entries_len * sizeof (CEntry*));

} while (!c_dynfect_inject (dynfect, list, bucket));

c_array_free (list);

}

else

{

c_dynfect_rehash (dynfect, new_entry);

}

return true;

}

static bool c_dynfect_remove (CDynfect* dynfect, const void* key)

{

dynfect->op_count++;

unsigned i = dynfect->key_hash_func (key, dynfect->random) %

(unsigned long) dynfect->buckets_len;

CBucket* bucket = &dynfect->buckets[i];

if (bucket->entries_len < 1)

return false;

int pos = dynfect->key_hash_func (key, bucket->random) %

(unsigned long) bucket->entries_len;

CEntry* entry = bucket->entries[pos];

if (entry == NULL)

return false;

c_list_remove_link (dynfect->list, (CNode*) entry);

bucket->entries[pos] = NULL;

if (dynfect->op_count >= dynfect->m)

c_dynfect_rehash (dynfect, NULL);

c_entry_free (entry, dynfect->key_free_func, dynfect->value_free_func);

return true;

}

static void* c_dynfect_lookup (CDynfect* dynfect, const void* key)

{

unsigned i = dynfect->key_hash_func (key, dynfect->random) % (unsigned long) dynfect->buckets_len;

CBucket* bucket = &dynfect->buckets[i];

if (bucket->entries_len > 0)

{

int pos = dynfect->key_hash_func (key, bucket->random) % (unsigned long) bucket->entries_len;

CEntry* entry = bucket->entries[pos];

if (entry && dynfect->key_equal_func (entry->key, key))

return entry->value;

}

return NULL;

}

static void c_dynfect_free (CDynfect* dynfect)

{

for (unsigned i = 0; i < dynfect->buckets_len; i++)

{

CBucket* bucket = &dynfect->buckets[i];

free (bucket->entries);

}

free (dynfect->buckets);

free (dynfect);

}

고정닉 0

전체 댓글 0개

등록순 최신순 답글순

본문 보기

타인의 권리를 침해하거나 명예를 훼손하는 댓글은 운영원칙 및 관련 법률에 제재를 받을 수 있습니다.
Shift+Enter 키를 동시에 누르면 줄바꿈이 됩니다.

갤러리 리스트
번호	제목	글쓴이	작성일	조회	추천
설문	모태 솔로도 구제해 줄 것 같은 연애 고수 스타는?	운영자	25/07/21	-	-
AD	곧 휴가!! 홈캉스, 바캉스 SALE	운영자	25/07/21	-	-
2874151	나님 냥덩이 누가 만진고양 [1]	아스카영원히사랑해	07.24	37	0
2874150	오늘의 섹스 실마리:	아스카영원히사랑해	07.24	29	0
2874149	아가냥 구해줄깡 말깡.. 흠..	♥팬티스타킹냥덩♥	07.24	19	0
2874148	리짜이밍 대통령 역시 퇴임 후 단죄해야 할 대상	아스카영원히사랑해	07.24	20	0
2874147	윤석열은 최소 무기징역이 옳다	아스카영원히사랑해	07.24	18	0
2874146	문재인 정부 때 안철수가 국무총리를 맡았다면 [2]	아스카영원히사랑해	07.24	36	0
2874145	새끼고양이 잡을까 말깡?	♥팬티스타킹냥덩♥	07.24	24	0
2874144	조선의 마지막 희망은 통일이다 [2]	아스카영원히사랑해	07.24	29	0
2874143	컴퓨터 책상 이쁘게 꾸미시는분?	질문왕(211.198)	07.24	21	0
2874141	주거냐 혁명이냐	ㅇㅇ(210.100)	07.24	22	0
2874139	나나이트 비슷한거 유니티에서 누가 구현하긴 했네	류도그담당(58.239)	07.24	36	0
2874138	아기다리고기다리던내일은월급날	아스카영원히사랑해	07.24	31	0
2874134	검은신화 오공 게임보는데 [5]	류도그담당(58.239)	07.24	55	0
2874130	폭염은 폭력이당 By 나님 [2]	♥팬티스타킹냥덩♥	07.24	33	0
2874129	미국: 대만 전쟁나면 한국 청년들이 미국 대신 싸우다 죽어라 명령 [1]	발명도둑잡기(118.216)	07.24	30	0
2874126	날씨 뭔데 ㅇㅅㅇ	류류(118.235)	07.24	18	0
2874125	데이터 복구 될까요 아예 하드가 인식이 안된데요..	넥도리아(220.74)	07.24	24	0
2874121	인지과학조져라	손발이시립디다	07.24	17	0
2874120	아이스크림처럼❤+ 달콤한 냥덩이에게 폭염은 다메다메 ㅠㅅㅠ	♥팬티스타킹냥덩♥	07.24	30	0
2874119	네트워크단에서 비트 단위로 표시하는거 나만 짜증나나 [1]	ㅇㅇ(110.10)	07.24	38	0
2874118	사실 프밍에 재능은 [4]	루도그담당(211.184)	07.24	59	0
2874116	2023년에 보배드림에 의사새끼가 아버지 의료사고로 안 좋게 만들어서,	넥도리아(220.74)	07.24	22	0
2874115	나님의 우울증 치료제는 에반게리온이었다 [3]	아스카영원히사랑해	07.24	60	0
2874114	애반게리온 보고 치유된과정 - eoe 랑 tva 후기 [4]	프갤러(183.101)	07.24	48	0
2874113	❤✨☀⭐⚡☘⛩나님 시작합니당⛩☘⚡⭐☀✨❤	♥팬티스타킹냥덩♥	07.24	18	0
2874112	나님 사교용 춤 배울깡 생각즁⭐+	♥팬티스타킹냥덩♥	07.24	21	0
2874111	곧 3년차인데 이제 이직 자리 알아봐야지 [1]	프갤러(118.235)	07.24	45	0
2874110	결국 프로그래밍이란 무엇인가	ㅆㅇㅆ찡	07.24	49	0
2874109	데이터 복구 맡기러 왔다가 집에와서 콩국수 먹었는데 인생에 덧이 없구나.	넥도리아(220.74)	07.24	26	0
2874108	프로그래밍의 개인적 허들은 실재적구조에서 개념적 구조로	ㅆㅇㅆ찡	07.24	34	0
2874107	2찢명 매번 미국에 입구컷 쫓겨나는꼴 ㄹㅇ 현웃터짐	♥팬티스타킹냥덩♥	07.24	27	0
2874106	2찢명 사람 쓰고 버리기 스킬 ㅆㅅㅌㅊ!	♥팬티스타킹냥덩♥	07.24	23	0
2874105	짱깨들도 2찢명 쿠폰으로 한국세금 달달하거이 빨아먹는즁 ㅋㅅㅋ	♥팬티스타킹냥덩♥	07.24	19	0
2874104	물리 배우다 프로그래밍으로 넘어가서 편했던점 [2]	ㅆㅇㅆ찡	07.24	58	0
2874103	나님만큼 최신 기술에 거부감 없이 잘쓰는 인재는 드뭄	♥팬티스타킹냥덩♥	07.24	29	0
2874102	여기서 조언바래봤자 딴데 가는게 나음 [2]	ㅆㅇㅆ찡	07.24	42	0
2874101	나님이 이번에 실험중인 항목들 ㅇㅅㅇ	♥팬티스타킹냥덩♥	07.24	20	0
2874100	2ㅌㅊ 까지는 올해마무리 할지 모르겠넹	♥팬티스타킹냥덩♥	07.24	20	0
2874099	늒비 간곡한 조언 부탁드립니다	프갤러(203.10)	07.24	27	0
2874098	요즘 사람들 이를 안 닦나보군요	루도그담당(211.184)	07.24	39	0
2874097	중간 일정까지 고려하면 올해 간당하겠고	♥팬티스타킹냥덩♥	07.24	16	0
2874096	단순 계산으로 75면.. 흠..	♥팬티스타킹냥덩♥	07.24	17	0
2874095	내일 출근 안합니다 ㅋ	루도그담당(211.184)	07.24	31	0
2874093	지방은 경력 10년도 연봉 5천 미만 수두룩하네	프갤러(218.238)	07.24	35	0
2874092	웹 영상 drm 걸린건 왠만해선 복호화 불가능함? [8]	ㅇㅇ(110.10)	07.24	66	0
2874091	프로그래밍 솔직히 한 5~6년전 코드보면 기억 안나서 느끼는거지만 [1]	ㅆㅇㅆ(124.216)	07.24	49	0
2874090	나님 통찰력 ㄱㅆㅅㅌㅊ..	♥팬티스타킹냥덩♥	07.24	18	0
2874089	언젠간 이 문서를 완성하는게 내 개인적 목표임 [2]	ㅆㅇㅆ(124.216)	07.24	42	0
2874088	저기 밑에 WPF 예제 추천해줌 ㅇㅇ [4]	ㅆㅇㅆ(124.216)	07.24	50	0
2874087	C#에서 고급 문법이랄게 뭐가 있을까 [1]	루도그담당(211.184)	07.24	42	0
뉴스	가수 소유, 성형설 루머에 직접 해명...10kg 감량에 앞트임은 메이크업	디시트렌드	07.24