#3548

Committed 04 Dec 2024 01:03PM UTC coverage: 59.846% (-0.8%) from 60.691%

Build # #3548

Build Type

push

travis-ci

Committed by

web-flow

Commit Message

Merge pull request #29033 from taosdata/fix/calculate-vnode-memory-used

fix/calculate-vnode-memory-used

Run Details

118484 of 254183 branches covered (46.61%)

Branch coverage included in aggregate %.

199691 of 277471 relevant lines covered (71.97%)

18794141.86 hits per line

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

59.29

/source/util/src/tunit.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 "tunit.h"

#define UNIT_SIZE_CONVERT_FACTOR 1024LL
#define UNIT_ONE_KIBIBYTE        UNIT_SIZE_CONVERT_FACTOR
#define UNIT_ONE_MEBIBYTE        (UNIT_ONE_KIBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
#define UNIT_ONE_GIBIBYTE        (UNIT_ONE_MEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
#define UNIT_ONE_TEBIBYTE        (UNIT_ONE_GIBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
#define UNIT_ONE_PEBIBYTE        (UNIT_ONE_TEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
#define UNIT_ONE_EXBIBYTE        (UNIT_ONE_PEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)

static int32_t parseCfgIntWithUnit(const char* str, int64_t* res) {
  double val = 0, temp = (double)INT64_MAX;
  char*  endPtr;
  bool   useDouble = false;
  errno = 0;
  int64_t int64Val = taosStr2Int64(str, &endPtr, 0);
  if (*endPtr == '.' || errno == ERANGE) {
    errno = 0;
    val = taosStr2Double(str, &endPtr);
    useDouble = true;
  }
  if (endPtr == str || errno == ERANGE || isnan(val)) {
    return terrno = TSDB_CODE_INVALID_CFG_VALUE;
  }
  while (isspace((unsigned char)*endPtr)) endPtr++;
  uint64_t factor = 1;
  if (*endPtr != '\0') {
    switch (*endPtr) {
      case 'P':
      case 'p': {
        temp /= UNIT_ONE_PEBIBYTE;
        factor = UNIT_ONE_PEBIBYTE;
      } break;
      case 'T':
      case 't': {
        temp /= UNIT_ONE_TEBIBYTE;
        factor = UNIT_ONE_TEBIBYTE;
      } break;
      case 'G':
      case 'g': {
        temp /= UNIT_ONE_GIBIBYTE;
        factor = UNIT_ONE_GIBIBYTE;
      } break;
      case 'M':
      case 'm': {
        temp /= UNIT_ONE_MEBIBYTE;
        factor = UNIT_ONE_MEBIBYTE;
      } break;
      case 'K':
      case 'k': {
        temp /= UNIT_ONE_KIBIBYTE;
        factor = UNIT_ONE_KIBIBYTE;
      } break;
      default:
        return terrno = TSDB_CODE_INVALID_CFG_VALUE;
    }
    endPtr++;

    if ((val > 0 && val > temp) || (val < 0 && val < -temp)) {
      return terrno = TSDB_CODE_OUT_OF_RANGE;
    }
    val *= factor;
    int64Val *= factor;
  }
  while (isspace((unsigned char)*endPtr)) endPtr++;
  if (*endPtr) {
    return terrno = TSDB_CODE_INVALID_CFG_VALUE;
  }
  if (useDouble) {
    val = rint(val);
    if ((val > 0 && val >= (double)INT64_MAX) || (val < 0 && val <= (double)INT64_MIN)) {
      return terrno = TSDB_CODE_OUT_OF_RANGE;
    } else {
      *res = (int64_t)val;
    }
  } else {
    *res = int64Val;
  }
  return TSDB_CODE_SUCCESS;
}

int32_t taosStrHumanToInt64(const char* str, int64_t* out) {
  int64_t  res;
  int32_t code = parseCfgIntWithUnit(str, &res);
  if (code == TSDB_CODE_SUCCESS) *out = (int64_t)res;
  return code;
}

#ifdef BUILD_NO_CALL
void taosInt64ToHumanStr(int64_t val, char* outStr) {
  if (((val >= UNIT_ONE_EXBIBYTE) || (-val >= UNIT_ONE_EXBIBYTE)) && ((val % UNIT_ONE_EXBIBYTE) == 0)) {
    sprintf(outStr, "%qdE", (long long)val / UNIT_ONE_EXBIBYTE);
  } else if (((val >= UNIT_ONE_PEBIBYTE) || (-val >= UNIT_ONE_PEBIBYTE)) && ((val % UNIT_ONE_PEBIBYTE) == 0)) {
    sprintf(outStr, "%qdP", (long long)val / UNIT_ONE_PEBIBYTE);
  } else if (((val >= UNIT_ONE_TEBIBYTE) || (-val >= UNIT_ONE_TEBIBYTE)) && ((val % UNIT_ONE_TEBIBYTE) == 0)) {
    sprintf(outStr, "%qdT", (long long)val / UNIT_ONE_TEBIBYTE);
  } else if (((val >= UNIT_ONE_GIBIBYTE) || (-val >= UNIT_ONE_GIBIBYTE)) && ((val % UNIT_ONE_GIBIBYTE) == 0)) {
    sprintf(outStr, "%qdG", (long long)val / UNIT_ONE_GIBIBYTE);
  } else if (((val >= UNIT_ONE_MEBIBYTE) || (-val >= UNIT_ONE_MEBIBYTE)) && ((val % UNIT_ONE_MEBIBYTE) == 0)) {
    sprintf(outStr, "%qdM", (long long)val / UNIT_ONE_MEBIBYTE);
  } else if (((val >= UNIT_ONE_KIBIBYTE) || (-val >= UNIT_ONE_KIBIBYTE)) && ((val % UNIT_ONE_KIBIBYTE) == 0)) {
    sprintf(outStr, "%qdK", (long long)val / UNIT_ONE_KIBIBYTE);
  } else
    sprintf(outStr, "%qd", (long long)val);
}
#endif

int32_t taosStrHumanToInt32(const char* str, int32_t* out) {
  int64_t  res;
  int32_t code = parseCfgIntWithUnit(str, &res);
  if (code == TSDB_CODE_SUCCESS) {
    if (res < INT32_MIN || res > INT32_MAX) {
      return terrno = TSDB_CODE_OUT_OF_RANGE;
    }
    *out = (int32_t)res;
  }
  return code;
}

#ifdef BUILD_NO_CALL
void taosInt32ToHumanStr(int32_t val, char* outStr) {
  if (((val >= UNIT_ONE_GIBIBYTE) || (-val >= UNIT_ONE_GIBIBYTE)) && ((val % UNIT_ONE_GIBIBYTE) == 0)) {
    sprintf(outStr, "%qdG", (long long)val / UNIT_ONE_GIBIBYTE);
  } else if (((val >= UNIT_ONE_MEBIBYTE) || (-val >= UNIT_ONE_MEBIBYTE)) && ((val % UNIT_ONE_MEBIBYTE) == 0)) {
    sprintf(outStr, "%qdM", (long long)val / UNIT_ONE_MEBIBYTE);
  } else if (((val >= UNIT_ONE_KIBIBYTE) || (-val >= UNIT_ONE_KIBIBYTE)) && ((val % UNIT_ONE_KIBIBYTE) == 0)) {
    sprintf(outStr, "%qdK", (long long)val / UNIT_ONE_KIBIBYTE);
  } else
    sprintf(outStr, "%qd", (long long)val);
}
#endif

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 "tunit.h"
17
18	#define UNIT_SIZE_CONVERT_FACTOR 1024LL
19	#define UNIT_ONE_KIBIBYTE UNIT_SIZE_CONVERT_FACTOR
20	#define UNIT_ONE_MEBIBYTE (UNIT_ONE_KIBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
21	#define UNIT_ONE_GIBIBYTE (UNIT_ONE_MEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
22	#define UNIT_ONE_TEBIBYTE (UNIT_ONE_GIBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
23	#define UNIT_ONE_PEBIBYTE (UNIT_ONE_TEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
24	#define UNIT_ONE_EXBIBYTE (UNIT_ONE_PEBIBYTE * UNIT_SIZE_CONVERT_FACTOR)
25
26	static int32_t parseCfgIntWithUnit(const char* str, int64_t* res) {	235,745✔
27	double val = 0, temp = (double)INT64_MAX;	235,745✔
28	char* endPtr;
29	bool useDouble = false;	235,745✔
30	errno = 0;	235,745✔
31	int64_t int64Val = taosStr2Int64(str, &endPtr, 0);	235,745✔
32	if (*endPtr == '.' \|\| errno == ERANGE) {	235,745!
33	errno = 0;	×
34	val = taosStr2Double(str, &endPtr);	×
35	useDouble = true;	×
36	}
37	if (endPtr == str \|\| errno == ERANGE \|\| isnan(val)) {	235,745!
38	return terrno = TSDB_CODE_INVALID_CFG_VALUE;	×
39	}
40	while (isspace((unsigned char)*endPtr)) endPtr++;	235,745!
41	uint64_t factor = 1;	235,745✔
42	if (*endPtr != '\0') {	235,745✔
43	switch (*endPtr) {	4!
44	case 'P':	1✔
45	case 'p': {
46	temp /= UNIT_ONE_PEBIBYTE;	1✔
47	factor = UNIT_ONE_PEBIBYTE;	1✔
48	} break;	1✔
49	case 'T':	1✔
50	case 't': {
51	temp /= UNIT_ONE_TEBIBYTE;	1✔
52	factor = UNIT_ONE_TEBIBYTE;	1✔
53	} break;	1✔
54	case 'G':	1✔
55	case 'g': {
56	temp /= UNIT_ONE_GIBIBYTE;	1✔
57	factor = UNIT_ONE_GIBIBYTE;	1✔
58	} break;	1✔
59	case 'M':	×
60	case 'm': {
61	temp /= UNIT_ONE_MEBIBYTE;	×
62	factor = UNIT_ONE_MEBIBYTE;	×
63	} break;	×
64	case 'K':	1✔
65	case 'k': {
66	temp /= UNIT_ONE_KIBIBYTE;	1✔
67	factor = UNIT_ONE_KIBIBYTE;	1✔
68	} break;	1✔
69	default:	×
70	return terrno = TSDB_CODE_INVALID_CFG_VALUE;	×
71	}
72	endPtr++;	4✔
73
74	if ((val > 0 && val > temp) \|\| (val < 0 && val < -temp)) {	4!
75	return terrno = TSDB_CODE_OUT_OF_RANGE;	×
76	}
77	val *= factor;	4✔
78	int64Val *= factor;	4✔
79	}
80	while (isspace((unsigned char)*endPtr)) endPtr++;	235,745!
81	if (*endPtr) {	235,745!
82	return terrno = TSDB_CODE_INVALID_CFG_VALUE;	×
83	}
84	if (useDouble) {	235,745!
85	val = rint(val);	×
86	if ((val > 0 && val >= (double)INT64_MAX) \|\| (val < 0 && val <= (double)INT64_MIN)) {	×
87	return terrno = TSDB_CODE_OUT_OF_RANGE;	×
88	} else {
89	*res = (int64_t)val;	×
90	}
91	} else {
92	*res = int64Val;	235,745✔
93	}
94	return TSDB_CODE_SUCCESS;	235,745✔
95	}
96
97	int32_t taosStrHumanToInt64(const char* str, int64_t* out) {	1,526✔
98	int64_t res;
99	int32_t code = parseCfgIntWithUnit(str, &res);	1,526✔
100	if (code == TSDB_CODE_SUCCESS) *out = (int64_t)res;	1,526!
101	return code;	1,526✔
102	}
103
104	#ifdef BUILD_NO_CALL
105	void taosInt64ToHumanStr(int64_t val, char* outStr) {
106	if (((val >= UNIT_ONE_EXBIBYTE) \|\| (-val >= UNIT_ONE_EXBIBYTE)) && ((val % UNIT_ONE_EXBIBYTE) == 0)) {
107	sprintf(outStr, "%qdE", (long long)val / UNIT_ONE_EXBIBYTE);
108	} else if (((val >= UNIT_ONE_PEBIBYTE) \|\| (-val >= UNIT_ONE_PEBIBYTE)) && ((val % UNIT_ONE_PEBIBYTE) == 0)) {
109	sprintf(outStr, "%qdP", (long long)val / UNIT_ONE_PEBIBYTE);
110	} else if (((val >= UNIT_ONE_TEBIBYTE) \|\| (-val >= UNIT_ONE_TEBIBYTE)) && ((val % UNIT_ONE_TEBIBYTE) == 0)) {
111	sprintf(outStr, "%qdT", (long long)val / UNIT_ONE_TEBIBYTE);
112	} else if (((val >= UNIT_ONE_GIBIBYTE) \|\| (-val >= UNIT_ONE_GIBIBYTE)) && ((val % UNIT_ONE_GIBIBYTE) == 0)) {
113	sprintf(outStr, "%qdG", (long long)val / UNIT_ONE_GIBIBYTE);
114	} else if (((val >= UNIT_ONE_MEBIBYTE) \|\| (-val >= UNIT_ONE_MEBIBYTE)) && ((val % UNIT_ONE_MEBIBYTE) == 0)) {
115	sprintf(outStr, "%qdM", (long long)val / UNIT_ONE_MEBIBYTE);
116	} else if (((val >= UNIT_ONE_KIBIBYTE) \|\| (-val >= UNIT_ONE_KIBIBYTE)) && ((val % UNIT_ONE_KIBIBYTE) == 0)) {
117	sprintf(outStr, "%qdK", (long long)val / UNIT_ONE_KIBIBYTE);
118	} else
119	sprintf(outStr, "%qd", (long long)val);
120	}
121	#endif
122
123	int32_t taosStrHumanToInt32(const char* str, int32_t* out) {	234,219✔
124	int64_t res;
125	int32_t code = parseCfgIntWithUnit(str, &res);	234,219✔
126	if (code == TSDB_CODE_SUCCESS) {	234,219!
127	if (res < INT32_MIN \|\| res > INT32_MAX) {	234,219!
128	return terrno = TSDB_CODE_OUT_OF_RANGE;	×
129	}
130	*out = (int32_t)res;	234,219✔
131	}
132	return code;	234,219✔
133	}
134
135	#ifdef BUILD_NO_CALL
136	void taosInt32ToHumanStr(int32_t val, char* outStr) {
137	if (((val >= UNIT_ONE_GIBIBYTE) \|\| (-val >= UNIT_ONE_GIBIBYTE)) && ((val % UNIT_ONE_GIBIBYTE) == 0)) {
138	sprintf(outStr, "%qdG", (long long)val / UNIT_ONE_GIBIBYTE);
139	} else if (((val >= UNIT_ONE_MEBIBYTE) \|\| (-val >= UNIT_ONE_MEBIBYTE)) && ((val % UNIT_ONE_MEBIBYTE) == 0)) {
140	sprintf(outStr, "%qdM", (long long)val / UNIT_ONE_MEBIBYTE);
141	} else if (((val >= UNIT_ONE_KIBIBYTE) \|\| (-val >= UNIT_ONE_KIBIBYTE)) && ((val % UNIT_ONE_KIBIBYTE) == 0)) {
142	sprintf(outStr, "%qdK", (long long)val / UNIT_ONE_KIBIBYTE);
143	} else
144	sprintf(outStr, "%qd", (long long)val);
145	}
146	#endif

taosdata / TDengine / #3548

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