#5060

Committed 17 May 2026 01:15AM UTC coverage: 73.425% (-0.02%) from 73.443%

Build # #5060

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

feat (TDgpt): Dynamic Model Synchronization Enhancements (#35344)

* refactor: do some internal refactor.

* fix: fix multiprocess sync issue.

* feat: add dynamic anomaly detection and forecasting services

* fix: log error message for undeploying model in exception handling

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* Potential fix for pull request finding

Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com>

* fix: handle undeploy when model exists only on disk

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/286aafa0-c3ce-4c27-b803-2707571e9dc1

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: guard dynamic registry concurrent access

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: tighten service list locking scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/5e4db858-6458-40f4-ac28-d1b1b7f97c18

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: restore prophet support and update tests per review feedback

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* fix: improve test name and move copy inside lock scope

Agent-Logs-Url: https://github.com/taosdata/TDengine/sessions/92298ae1-7da6-4d07-b20e-101c7cd0b26b

Co-authored-by: hjxilinx <8252296+hjxilinx@users.noreply.github.com>

* Potential fix for pull request finding

Co-au... (continued)

Coverage Stats

281800 of 383795 relevant lines covered (73.42%)

134332207.97 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

85.0

/source/dnode/vnode/src/vnd/vnodeHash.c

/*
 * Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
 *
 * This program is free software: you can use, redistribute, and/or modify
 * it under the terms of the GNU Affero General Public License, version 3
 * or later ("AGPL"), as published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 */

#include "vnodeHash.h"

#define VNODE_HASH_DEFAULT_NUM_BUCKETS 1024

typedef struct SVHashEntry SVHashEntry;

struct SVHashEntry {
  SVHashEntry* next;
  void*        obj;
};

static void vHashRehash(SVHashTable* ht, uint32_t newNumBuckets) {
  SVHashEntry** newBuckets = (SVHashEntry**)taosMemoryCalloc(newNumBuckets, sizeof(SVHashEntry*));
  if (newBuckets == NULL) {
    return;
  }

  for (int32_t i = 0; i < ht->numBuckets; i++) {
    SVHashEntry* entry = ht->buckets[i];
    while (entry != NULL) {
      SVHashEntry* next = entry->next;
      uint32_t     bucketIndex = ht->hash(entry->obj) % newNumBuckets;
      entry->next = newBuckets[bucketIndex];
      newBuckets[bucketIndex] = entry;
      entry = next;
    }
  }

  taosMemoryFree(ht->buckets);
  ht->buckets = newBuckets;
  ht->numBuckets = newNumBuckets;

  return;
}

int32_t vHashInit(SVHashTable** ht, uint32_t (*hash)(const void*), int32_t (*compare)(const void*, const void*)) {
  if (ht == NULL || hash == NULL || compare == NULL) {
    return TSDB_CODE_INVALID_PARA;
  }

  (*ht) = (SVHashTable*)taosMemoryMalloc(sizeof(SVHashTable));
  if (*ht == NULL) {
    return terrno;
  }

  (*ht)->hash = hash;
  (*ht)->compare = compare;
  (*ht)->numEntries = 0;
  (*ht)->numBuckets = VNODE_HASH_DEFAULT_NUM_BUCKETS;
  (*ht)->buckets = (SVHashEntry**)taosMemoryCalloc((*ht)->numBuckets, sizeof(SVHashEntry*));
  if ((*ht)->buckets == NULL) {
    taosMemoryFree(*ht);
    return terrno;
  }

  return 0;
}

void vHashDestroy(SVHashTable** ht) {
  if (ht == NULL) {
    return;
  }

  if (*ht) {
    taosMemoryFree((*ht)->buckets);
    taosMemoryFree(*ht);
    (*ht) = NULL;
  }
}

int32_t vHashPut(SVHashTable* ht, void* obj) {
  if (ht == NULL || obj == NULL) {
    return TSDB_CODE_INVALID_PARA;
  }

  uint32_t bucketIndex = ht->hash(obj) % ht->numBuckets;
  for (SVHashEntry* entry = ht->buckets[bucketIndex]; entry != NULL; entry = entry->next) {
    if (ht->compare(entry->obj, obj) == 0) {
      return TSDB_CODE_DUP_KEY;
    }
  }

  if (ht->numEntries >= ht->numBuckets) {
    vHashRehash(ht, ht->numBuckets * 2);
    bucketIndex = ht->hash(obj) % ht->numBuckets;
  }

  SVHashEntry* entry = (SVHashEntry*)taosMemoryMalloc(sizeof(SVHashEntry));
  if (entry == NULL) {
    return terrno;
  }
  entry->obj = obj;
  entry->next = ht->buckets[bucketIndex];
  ht->buckets[bucketIndex] = entry;
  ht->numEntries++;

  return 0;
}

int32_t vHashGet(SVHashTable* ht, const void* obj, void** retObj) {
  if (ht == NULL || obj == NULL || retObj == NULL) {
    return TSDB_CODE_INVALID_PARA;
  }

  uint32_t bucketIndex = ht->hash(obj) % ht->numBuckets;
  for (SVHashEntry* entry = ht->buckets[bucketIndex]; entry != NULL; entry = entry->next) {
    if (ht->compare(entry->obj, obj) == 0) {
      *retObj = entry->obj;
      return 0;
    }
  }

  *retObj = NULL;
  return TSDB_CODE_NOT_FOUND;
}

int32_t vHashDrop(SVHashTable* ht, const void* obj) {
  if (ht == NULL || obj == NULL) {
    return TSDB_CODE_INVALID_PARA;
  }

  uint32_t bucketIndex = ht->hash(obj) % ht->numBuckets;
  for (SVHashEntry** entry = &ht->buckets[bucketIndex]; *entry != NULL; entry = &(*entry)->next) {
    if (ht->compare((*entry)->obj, obj) == 0) {
      SVHashEntry* tmp = *entry;
      *entry = (*entry)->next;
      taosMemoryFree(tmp);
      ht->numEntries--;
      if (ht->numBuckets > VNODE_HASH_DEFAULT_NUM_BUCKETS && ht->numEntries < ht->numBuckets / 4) {
        vHashRehash(ht, ht->numBuckets / 2);
      }
      return 0;
    }
  }

  return TSDB_CODE_NOT_FOUND;
}

1	/*
2	* Copyright (c) 2019 TAOS Data, Inc. <jhtao@taosdata.com>
3	*
4	* This program is free software: you can use, redistribute, and/or modify
5	* it under the terms of the GNU Affero General Public License, version 3
6	* or later ("AGPL"), as published by the Free Software Foundation.
7	*
8	* This program is distributed in the hope that it will be useful, but WITHOUT
9	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
10	* FITNESS FOR A PARTICULAR PURPOSE.
11	*
12	* You should have received a copy of the GNU Affero General Public License
13	* along with this program. If not, see <http://www.gnu.org/licenses/>.
14	*/
15
16	#include "vnodeHash.h"
17
18	#define VNODE_HASH_DEFAULT_NUM_BUCKETS 1024
19
20	typedef struct SVHashEntry SVHashEntry;
21
22	struct SVHashEntry {
23	SVHashEntry* next;
24	void* obj;
25	};
26
27	static void vHashRehash(SVHashTable* ht, uint32_t newNumBuckets) {	17,848✔
28	SVHashEntry newBuckets = (SVHashEntry)taosMemoryCalloc(newNumBuckets, sizeof(SVHashEntry*));	17,848✔
29	if (newBuckets == NULL) {	17,848✔
30	return;	×
31	}
32
33	for (int32_t i = 0; i < ht->numBuckets; i++) {	27,432,376✔
34	SVHashEntry* entry = ht->buckets[i];	27,414,528✔
35	while (entry != NULL) {	41,112,868✔
36	SVHashEntry* next = entry->next;	13,698,340✔
37	uint32_t bucketIndex = ht->hash(entry->obj) % newNumBuckets;	13,698,340✔
38	entry->next = newBuckets[bucketIndex];	13,698,340✔
39	newBuckets[bucketIndex] = entry;	13,698,340✔
40	entry = next;	13,698,340✔
41	}
42	}
43
44	taosMemoryFree(ht->buckets);	17,848✔
45	ht->buckets = newBuckets;	17,848✔
46	ht->numBuckets = newNumBuckets;	17,848✔
47
48	return;	17,848✔
49	}
50
51	int32_t vHashInit(SVHashTable** ht, uint32_t (hash)(const void), int32_t (compare)(const void, const void*)) {	10,877,916✔
52	if (ht == NULL \|\| hash == NULL \|\| compare == NULL) {	10,877,916✔
53	return TSDB_CODE_INVALID_PARA;	×
54	}
55
56	(ht) = (SVHashTable)taosMemoryMalloc(sizeof(SVHashTable));	10,877,916✔
57	if (*ht == NULL) {	10,878,340✔
58	return terrno;	×
59	}
60
61	(*ht)->hash = hash;	10,878,340✔
62	(*ht)->compare = compare;	10,877,916✔
63	(*ht)->numEntries = 0;	10,877,916✔
64	(*ht)->numBuckets = VNODE_HASH_DEFAULT_NUM_BUCKETS;	10,877,916✔
65	(ht)->buckets = (SVHashEntry)taosMemoryCalloc((ht)->numBuckets, sizeof(SVHashEntry*));	10,877,089✔
66	if ((*ht)->buckets == NULL) {	10,878,340✔
67	taosMemoryFree(*ht);	×
68	return terrno;	×
69	}
70
71	return 0;	10,878,340✔
72	}
73
74	void vHashDestroy(SVHashTable** ht) {	10,878,340✔
75	if (ht == NULL) {	10,878,340✔
76	return;	×
77	}
78
79	if (*ht) {	10,878,340✔
80	taosMemoryFree((*ht)->buckets);	10,878,340✔
81	taosMemoryFree(*ht);	10,878,340✔
82	(*ht) = NULL;	10,878,340✔
83	}
84	}
85
86	int32_t vHashPut(SVHashTable* ht, void* obj) {	28,176,505✔
87	if (ht == NULL \|\| obj == NULL) {	28,176,505✔
88	return TSDB_CODE_INVALID_PARA;	×
89	}
90
91	uint32_t bucketIndex = ht->hash(obj) % ht->numBuckets;	28,178,945✔
92	for (SVHashEntry* entry = ht->buckets[bucketIndex]; entry != NULL; entry = entry->next) {	36,672,734✔
93	if (ht->compare(entry->obj, obj) == 0) {	8,463,714✔
94	return TSDB_CODE_DUP_KEY;	×
95	}
96	}
97
98	if (ht->numEntries >= ht->numBuckets) {	28,165,191✔
99	vHashRehash(ht, ht->numBuckets * 2);	8,924✔
100	bucketIndex = ht->hash(obj) % ht->numBuckets;	8,924✔
101	}
102
103	SVHashEntry* entry = (SVHashEntry*)taosMemoryMalloc(sizeof(SVHashEntry));	28,177,627✔
104	if (entry == NULL) {	28,178,976✔
105	return terrno;	×
106	}
107	entry->obj = obj;	28,178,976✔
108	entry->next = ht->buckets[bucketIndex];	28,179,111✔
109	ht->buckets[bucketIndex] = entry;	28,178,364✔
110	ht->numEntries++;	28,178,902✔
111
112	return 0;	28,177,458✔
113	}
114
115	int32_t vHashGet(SVHashTable* ht, const void* obj, void** retObj) {	122,861,580✔
116	if (ht == NULL \|\| obj == NULL \|\| retObj == NULL) {	122,861,580✔
117	return TSDB_CODE_INVALID_PARA;	×
118	}
119
120	uint32_t bucketIndex = ht->hash(obj) % ht->numBuckets;	122,880,180✔
121	for (SVHashEntry* entry = ht->buckets[bucketIndex]; entry != NULL; entry = entry->next) {	140,597,294✔
122	if (ht->compare(entry->obj, obj) == 0) {	113,223,629✔
123	*retObj = entry->obj;	95,481,818✔
124	return 0;	95,480,164✔
125	}
126	}
127
128	*retObj = NULL;	27,372,961✔
129	return TSDB_CODE_NOT_FOUND;	27,372,288✔
130	}
131
132	int32_t vHashDrop(SVHashTable* ht, const void* obj) {	28,180,195✔
133	if (ht == NULL \|\| obj == NULL) {	28,180,195✔
134	return TSDB_CODE_INVALID_PARA;	×
135	}
136
137	uint32_t bucketIndex = ht->hash(obj) % ht->numBuckets;	28,180,195✔
138	for (SVHashEntry** entry = &ht->buckets[bucketIndex]; entry != NULL; entry = &(entry)->next) {	31,772,304✔
139	if (ht->compare((*entry)->obj, obj) == 0) {	31,772,304✔
140	SVHashEntry* tmp = *entry;	28,180,195✔
141	entry = (entry)->next;	28,180,195✔
142	taosMemoryFree(tmp);	28,180,195✔
143	ht->numEntries--;	28,180,195✔
144	if (ht->numBuckets > VNODE_HASH_DEFAULT_NUM_BUCKETS && ht->numEntries < ht->numBuckets / 4) {	28,180,195✔
145	vHashRehash(ht, ht->numBuckets / 2);	8,924✔
146	}
147	return 0;	28,179,548✔
148	}
149	}
150
151	return TSDB_CODE_NOT_FOUND;	×
152	}

taosdata / TDengine / #5060

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous