665 lines
20 KiB
C++
665 lines
20 KiB
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 <gtest/gtest.h>
|
|
#include <inttypes.h>
|
|
#include <iostream>
|
|
|
|
#pragma GCC diagnostic push
|
|
#pragma GCC diagnostic ignored "-Wwrite-strings"
|
|
#pragma GCC diagnostic ignored "-Wunused-function"
|
|
#pragma GCC diagnostic ignored "-Wunused-variable"
|
|
#pragma GCC diagnostic ignored "-Wsign-compare"
|
|
#pragma GCC diagnostic ignored "-Wsign-compare"
|
|
#pragma GCC diagnostic ignored "-Wformat"
|
|
#pragma GCC diagnostic ignored "-Wint-to-pointer-cast"
|
|
#pragma GCC diagnostic ignored "-Wpointer-arith"
|
|
|
|
#include "os.h"
|
|
#include "tlog.h"
|
|
|
|
#ifdef WINDOWS
|
|
#include <windows.h>
|
|
#else
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
TEST(osTest, locale) {
|
|
char *ret = taosCharsetReplace(NULL);
|
|
EXPECT_EQ(ret, nullptr);
|
|
|
|
ret = taosCharsetReplace("utf8");
|
|
EXPECT_NE(ret, nullptr);
|
|
|
|
ret = taosCharsetReplace("utf-8");
|
|
EXPECT_NE(ret, nullptr);
|
|
|
|
taosGetSystemLocale(NULL, "");
|
|
taosGetSystemLocale("", NULL);
|
|
}
|
|
|
|
TEST(osTest, memory) {
|
|
int32_t ret = taosMemoryDbgInitRestore();
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
int64_t ret64 = taosMemSize(NULL);
|
|
EXPECT_EQ(ret64, 0);
|
|
}
|
|
|
|
TEST(osTest, rand2) {
|
|
char str[128] = {0};
|
|
taosRandStr2(str, 100);
|
|
}
|
|
|
|
TEST(osTest, socket2) {
|
|
int32_t ret32 = taosCloseSocket(NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
ret32 = taosSetSockOpt(NULL, 0, 0, NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
#if defined(LINUX)
|
|
struct in_addr ipInt;
|
|
ipInt.s_addr = htonl(0x7F000001);
|
|
char buf[128] = {0};
|
|
taosInetNtop(ipInt, buf, 32);
|
|
#endif
|
|
|
|
ret32 = taosGetIpv4FromFqdn("localhost", NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
uint32_t ip = 0;
|
|
ret32 = taosGetIpv4FromFqdn(NULL, &ip);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
taosInetNtoa(NULL, ip);
|
|
ret32 = taosInetAddr(NULL);
|
|
EXPECT_EQ(ret32, 0);
|
|
|
|
ret32 = taosWinSocketInit();
|
|
EXPECT_EQ(ret32, 0);
|
|
}
|
|
|
|
TEST(osTest, time2) {
|
|
taosGetLocalTimezoneOffset();
|
|
|
|
char buf[12] = {0};
|
|
char fmt[12] = {0};
|
|
void *retptr = taosStrpTime(NULL, fmt, NULL);
|
|
EXPECT_EQ(retptr, nullptr);
|
|
retptr = taosStrpTime(buf, NULL, NULL);
|
|
EXPECT_EQ(retptr, nullptr);
|
|
|
|
size_t ret = taosStrfTime(NULL, 0, fmt, NULL);
|
|
EXPECT_EQ(ret, 0);
|
|
ret = taosStrfTime(buf, 0, NULL, NULL);
|
|
EXPECT_EQ(ret, 0);
|
|
|
|
time_t tp = {0};
|
|
struct tm *retptr2 = taosGmTimeR(&tp, NULL);
|
|
EXPECT_EQ(retptr2, nullptr);
|
|
retptr2 = taosGmTimeR(NULL, NULL);
|
|
EXPECT_EQ(retptr2, nullptr);
|
|
|
|
time_t rett = taosTimeGm(NULL);
|
|
EXPECT_EQ(rett, -1);
|
|
|
|
timezone_t tz = {0};
|
|
retptr2 = taosLocalTime(&tp, NULL, NULL, 0, tz);
|
|
EXPECT_EQ(retptr2, nullptr);
|
|
retptr2 = taosLocalTime(NULL, NULL, NULL, 0, tz);
|
|
EXPECT_EQ(retptr2, nullptr);
|
|
}
|
|
|
|
TEST(osTest, system) {
|
|
#if defined(LINUX)
|
|
taosSetConsoleEcho(false);
|
|
taosSetConsoleEcho(true);
|
|
|
|
taosGetOldTerminalMode();
|
|
taosCloseCmd(NULL);
|
|
|
|
TdCmdPtr ptr = taosOpenCmd(NULL);
|
|
EXPECT_EQ(ptr, nullptr);
|
|
taosCloseCmd(&ptr);
|
|
|
|
ptr = taosOpenCmd("echo 'hello world'");
|
|
ASSERT_NE(ptr, nullptr);
|
|
|
|
char buf[256] = {0};
|
|
int64_t ret64 = taosGetsCmd(NULL, 0, NULL);
|
|
EXPECT_LE(ret64, 0);
|
|
ret64 = taosGetsCmd(ptr, 0, NULL);
|
|
EXPECT_LE(ret64, 0);
|
|
ret64 = taosGetsCmd(ptr, 255, buf);
|
|
EXPECT_GT(ret64, 0);
|
|
taosCloseCmd(&ptr);
|
|
|
|
ptr = taosOpenCmd("echoxxx 'hello world'");
|
|
ASSERT_NE(ptr, nullptr);
|
|
ret64 = taosGetsCmd(ptr, 255, buf);
|
|
EXPECT_LE(ret64, 0);
|
|
taosCloseCmd(&ptr);
|
|
|
|
ret64 = taosGetLineCmd(NULL, NULL);
|
|
EXPECT_LE(ret64, 0);
|
|
ret64 = taosGetLineCmd(ptr, NULL);
|
|
EXPECT_LE(ret64, 0);
|
|
|
|
ptr = taosOpenCmd("echo 'hello world'");
|
|
ASSERT_NE(ptr, nullptr);
|
|
char *ptrBuf = NULL;
|
|
ret64 = taosGetLineCmd(ptr, &ptrBuf);
|
|
EXPECT_GE(ret64, 0);
|
|
taosCloseCmd(&ptr);
|
|
|
|
ptr = taosOpenCmd("echoxxx 'hello world'");
|
|
ASSERT_NE(ptr, nullptr);
|
|
ret64 = taosGetLineCmd(ptr, &ptrBuf);
|
|
EXPECT_LE(ret64, 0);
|
|
taosCloseCmd(&ptr);
|
|
|
|
int32_t ret32 = taosEOFCmd(NULL);
|
|
EXPECT_EQ(ret32, 0);
|
|
|
|
#endif
|
|
}
|
|
|
|
TEST(osTest, sysinfo) {
|
|
#if defined(LINUX)
|
|
|
|
int32_t ret32 = 0;
|
|
|
|
ret32 = taosGetEmail(NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
ret32 = taosGetOsReleaseName(NULL, NULL, NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
char buf[128] = {0};
|
|
float numOfCores = 0;
|
|
ret32 = taosGetCpuInfo(buf, 0, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetCpuInfo(NULL, 0, &numOfCores);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
|
|
ret32 = taosGetCpuCores(NULL, false);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetTotalMemory(NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetProcMemory(NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetSysMemory(NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
ret32 = taosGetDiskSize(buf, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
SDiskSize disksize = {0};
|
|
ret32 = taosGetDiskSize(NULL, &disksize);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
int64_t tmp = 0;
|
|
ret32 = taosGetProcIO(NULL, NULL, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetProcIO(&tmp, NULL, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetProcIO(&tmp, &tmp, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetProcIO(&tmp, &tmp, &tmp, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
ret32 = taosGetProcIODelta(NULL, NULL, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetProcIODelta(&tmp, NULL, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetProcIODelta(&tmp, &tmp, NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetProcIODelta(&tmp, &tmp, &tmp, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
taosGetProcIODelta(NULL, NULL, NULL, NULL);
|
|
taosGetProcIODelta(&tmp, &tmp, &tmp, &tmp);
|
|
|
|
ret32 = taosGetCardInfo(NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetCardInfo(&tmp, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
ret32 = taosGetCardInfoDelta(NULL, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetCardInfoDelta(&tmp, NULL);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
taosGetCardInfoDelta(NULL, NULL);
|
|
taosGetCardInfoDelta(&tmp, &tmp);
|
|
|
|
ret32 = taosGetSystemUUIDLimit36(NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
ret32 = taosGetSystemUUIDLen(NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
ret32 = taosGetSystemUUIDLen(buf, -1);
|
|
EXPECT_NE(ret32, 0);
|
|
|
|
taosSetCoreDump(false);
|
|
|
|
ret32 = taosGetlocalhostname(NULL, 0);
|
|
EXPECT_NE(ret32, 0);
|
|
#endif
|
|
}
|
|
|
|
TEST(osTest, osFQDNSuccess) {
|
|
char fqdn[TD_FQDN_LEN];
|
|
char ipString[INET_ADDRSTRLEN];
|
|
int code = taosGetFqdn(fqdn);
|
|
uint32_t ipv4 = 0;
|
|
code = taosGetIpv4FromFqdn(fqdn, &ipv4);
|
|
ASSERT_NE(ipv4, 0xffffffff);
|
|
|
|
struct in_addr addr;
|
|
addr.s_addr = htonl(ipv4);
|
|
(void)snprintf(ipString, INET_ADDRSTRLEN, "%u.%u.%u.%u", (unsigned int)(addr.s_addr >> 24) & 0xFF,
|
|
(unsigned int)(addr.s_addr >> 16) & 0xFF, (unsigned int)(addr.s_addr >> 8) & 0xFF,
|
|
(unsigned int)(addr.s_addr) & 0xFF);
|
|
(void)printf("fqdn:%s ip:%s\n", fqdn, ipString);
|
|
}
|
|
|
|
TEST(osTest, osFQDNFailed) {
|
|
char fqdn[1024] = "fqdn_test_not_found";
|
|
char ipString[24];
|
|
uint32_t ipv4 = 0;
|
|
int32_t code = taosGetIpv4FromFqdn(fqdn, &ipv4);
|
|
ASSERT_NE(code, 0);
|
|
|
|
terrno = TSDB_CODE_RPC_FQDN_ERROR;
|
|
(void)printf("fqdn:%s transfer to ip failed!\n", fqdn);
|
|
}
|
|
|
|
#endif // WINDOWS
|
|
|
|
TEST(osTest, osSystem) {
|
|
const char *flags = "UTL FATAL ";
|
|
ELogLevel level = DEBUG_FATAL;
|
|
int32_t dflag = 255; // tsLogEmbedded ? 255 : uDebugFlag
|
|
taosPrintTrace(flags, level, dflag, 0);
|
|
|
|
const int sysLen = 64;
|
|
char osSysName[sysLen];
|
|
int ret = taosGetOsReleaseName(osSysName, NULL, NULL, sysLen);
|
|
(void)printf("os system name:%s\n", osSysName);
|
|
ASSERT_EQ(ret, 0);
|
|
}
|
|
|
|
void fileOperateOnFree(void *param) {
|
|
char *fname = (char *)param;
|
|
TdFilePtr pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_WRITE);
|
|
(void)printf("On free thread open file\n");
|
|
ASSERT_NE(pFile, nullptr);
|
|
|
|
int ret = taosLockFile(pFile);
|
|
(void)printf("On free thread lock file ret:%d\n", ret);
|
|
ASSERT_EQ(ret, 0);
|
|
|
|
ret = taosUnLockFile(pFile);
|
|
(void)printf("On free thread unlock file ret:%d\n", ret);
|
|
ASSERT_EQ(ret, 0);
|
|
|
|
ret = taosCloseFile(&pFile);
|
|
ASSERT_EQ(ret, 0);
|
|
(void)printf("On free thread close file ret:%d\n", ret);
|
|
}
|
|
void *fileOperateOnFreeThread(void *param) {
|
|
fileOperateOnFree(param);
|
|
return NULL;
|
|
}
|
|
void fileOperateOnBusy(void *param) {
|
|
char *fname = (char *)param;
|
|
TdFilePtr pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_WRITE);
|
|
(void)printf("On busy thread open file\n");
|
|
if (pFile == NULL) return;
|
|
// ASSERT_NE(pFile, nullptr);
|
|
|
|
int ret = taosLockFile(pFile);
|
|
(void)printf("On busy thread lock file ret:%d\n", ret);
|
|
ASSERT_NE(ret, 0);
|
|
|
|
ret = taosUnLockFile(pFile);
|
|
(void)printf("On busy thread unlock file ret:%d\n", ret);
|
|
|
|
ret = taosCloseFile(&pFile);
|
|
(void)printf("On busy thread close file ret:%d\n", ret);
|
|
ASSERT_EQ(ret, 0);
|
|
}
|
|
void *fileOperateOnBusyThread(void *param) {
|
|
fileOperateOnBusy(param);
|
|
return NULL;
|
|
}
|
|
|
|
TEST(osTest, osFile) {
|
|
char *fname = "./osfiletest1.txt";
|
|
|
|
TdFilePtr pOutFD = taosCreateFile(fname, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC);
|
|
ASSERT_NE(pOutFD, nullptr);
|
|
(void)printf("create file success\n");
|
|
(void)taosCloseFile(&pOutFD);
|
|
|
|
(void)taosCloseFile(&pOutFD);
|
|
|
|
TdFilePtr pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_WRITE);
|
|
(void)printf("open file\n");
|
|
ASSERT_NE(pFile, nullptr);
|
|
|
|
int ret = taosLockFile(pFile);
|
|
(void)printf("lock file ret:%d\n", ret);
|
|
ASSERT_EQ(ret, 0);
|
|
|
|
TdThreadAttr thattr;
|
|
(void)taosThreadAttrInit(&thattr);
|
|
|
|
TdThread thread1, thread2;
|
|
(void)taosThreadCreate(&(thread1), &thattr, fileOperateOnBusyThread, (void *)fname);
|
|
(void)taosThreadAttrDestroy(&thattr);
|
|
|
|
(void)taosThreadJoin(thread1, NULL);
|
|
taosThreadClear(&thread1);
|
|
|
|
ret = taosUnLockFile(pFile);
|
|
(void)printf("unlock file ret:%d\n", ret);
|
|
ASSERT_EQ(ret, 0);
|
|
|
|
ret = taosCloseFile(&pFile);
|
|
(void)printf("close file ret:%d\n", ret);
|
|
ASSERT_EQ(ret, 0);
|
|
|
|
(void)taosThreadCreate(&(thread2), &thattr, fileOperateOnFreeThread, (void *)fname);
|
|
(void)taosThreadAttrDestroy(&thattr);
|
|
|
|
(void)taosThreadJoin(thread2, NULL);
|
|
taosThreadClear(&thread2);
|
|
|
|
taosRemoveFile(fname);
|
|
// ASSERT_EQ(ret, 0);
|
|
// printf("remove file success");
|
|
}
|
|
|
|
#ifndef OSFILE_PERFORMANCE_TEST
|
|
|
|
#define MAX_WORDS 100
|
|
#define MAX_WORD_LENGTH 20
|
|
#define MAX_TEST_FILE_SIZE 100000
|
|
#define TESTTIMES 1000
|
|
|
|
char *getRandomWord() {
|
|
static char words[][MAX_WORD_LENGTH] = {"Lorem",
|
|
"ipsum",
|
|
"dolor",
|
|
"sit",
|
|
"amet",
|
|
"consectetur",
|
|
"adipiscing",
|
|
"elit",
|
|
"sed",
|
|
"do",
|
|
"eiusmod",
|
|
"tempor",
|
|
"incididunt",
|
|
"ut",
|
|
"labore",
|
|
"et",
|
|
"dolore",
|
|
"magna",
|
|
"aliqua",
|
|
"Ut",
|
|
"enim",
|
|
"ad",
|
|
"minim",
|
|
"veniam",
|
|
"quis",
|
|
"nostrud",
|
|
"exercitation",
|
|
"ullamco",
|
|
"Why",
|
|
"do",
|
|
"programmers",
|
|
"prefer",
|
|
"using",
|
|
"dark",
|
|
"mode?",
|
|
"Because",
|
|
"light",
|
|
"attracts",
|
|
"bugs",
|
|
"and",
|
|
"they",
|
|
"want",
|
|
"to",
|
|
"code",
|
|
"in",
|
|
"peace,",
|
|
"like",
|
|
"a",
|
|
"ninja",
|
|
"in",
|
|
"the",
|
|
"shadows."
|
|
"aliqua",
|
|
"Ut",
|
|
"enim",
|
|
"ad",
|
|
"minim",
|
|
"veniam",
|
|
"quis",
|
|
"nostrud",
|
|
"exercitation",
|
|
"ullamco",
|
|
"laboris",
|
|
"nisi",
|
|
"ut",
|
|
"aliquip",
|
|
"ex",
|
|
"ea",
|
|
"commodo",
|
|
"consequat",
|
|
"Duis",
|
|
"aute",
|
|
"irure",
|
|
"dolor",
|
|
"in",
|
|
"reprehenderit",
|
|
"in",
|
|
"voluptate",
|
|
"velit",
|
|
"esse",
|
|
"cillum",
|
|
"dolore",
|
|
"eu",
|
|
"fugiat",
|
|
"nulla",
|
|
"pariatur",
|
|
"Excepteur",
|
|
"sint",
|
|
"occaecat",
|
|
"cupidatat",
|
|
"non",
|
|
"proident",
|
|
"sunt",
|
|
"in",
|
|
"culpa",
|
|
"qui",
|
|
"officia",
|
|
"deserunt",
|
|
"mollit",
|
|
"anim",
|
|
"id",
|
|
"est",
|
|
"laborum"};
|
|
|
|
return words[taosRand() % MAX_WORDS];
|
|
}
|
|
|
|
int64_t fillBufferWithRandomWords(char *buffer, int64_t maxBufferSize) {
|
|
int64_t len = 0;
|
|
while (len < maxBufferSize) {
|
|
char *word = getRandomWord();
|
|
size_t wordLen = strlen(word);
|
|
|
|
if (len + wordLen + 1 < maxBufferSize) {
|
|
(void)strcat(buffer, word);
|
|
(void)strcat(buffer, " ");
|
|
len += wordLen + 1;
|
|
} else {
|
|
break;
|
|
}
|
|
}
|
|
return len;
|
|
}
|
|
|
|
int64_t calculateAverage(int64_t arr[], int size) {
|
|
int64_t sum = 0;
|
|
for (int i = 0; i < size; i++) {
|
|
sum += arr[i];
|
|
}
|
|
return sum / size;
|
|
}
|
|
|
|
int64_t calculateMax(int64_t arr[], int size) {
|
|
int64_t max = arr[0];
|
|
for (int i = 1; i < size; i++) {
|
|
if (arr[i] > max) {
|
|
max = arr[i];
|
|
}
|
|
}
|
|
return max;
|
|
}
|
|
|
|
int64_t calculateMin(int64_t arr[], int size) {
|
|
int64_t min = arr[0];
|
|
for (int i = 1; i < size; i++) {
|
|
if (arr[i] < min) {
|
|
min = arr[i];
|
|
}
|
|
}
|
|
return min;
|
|
}
|
|
|
|
TEST(osTest, osFilePerformance) {
|
|
(void)printf("os file performance testting...\n");
|
|
int64_t WriteFileCost;
|
|
int64_t ReadFileCost;
|
|
int64_t OpenForWriteCloseFileCost;
|
|
int64_t OpenForReadCloseFileCost;
|
|
|
|
char *buffer;
|
|
char *writeBuffer = (char *)taosMemoryCalloc(1, MAX_TEST_FILE_SIZE);
|
|
char *readBuffer = (char *)taosMemoryCalloc(1, MAX_TEST_FILE_SIZE);
|
|
int64_t size = fillBufferWithRandomWords(writeBuffer, MAX_TEST_FILE_SIZE);
|
|
char *fname = "./osFilePerformanceTest.txt";
|
|
|
|
TdFilePtr pOutFD = taosCreateFile(fname, TD_FILE_WRITE | TD_FILE_CREATE | TD_FILE_TRUNC);
|
|
ASSERT_NE(pOutFD, nullptr);
|
|
(void)taosCloseFile(&pOutFD);
|
|
|
|
(void)printf("os file performance start write...\n");
|
|
int64_t t1 = taosGetTimestampUs();
|
|
for (int i = 0; i < TESTTIMES; ++i) {
|
|
TdFilePtr pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_WRITE | TD_FILE_WRITE_THROUGH);
|
|
ASSERT_NE(pFile, nullptr);
|
|
(void)taosWriteFile(pFile, writeBuffer, size);
|
|
(void)taosFsyncFile(pFile);
|
|
(void)taosCloseFile(&pFile);
|
|
}
|
|
|
|
int64_t t2 = taosGetTimestampUs();
|
|
WriteFileCost = t2 - t1;
|
|
|
|
(void)printf("os file performance start read...\n");
|
|
for (int i = 0; i < TESTTIMES; ++i) {
|
|
TdFilePtr pFile = taosOpenFile(fname, TD_FILE_READ);
|
|
ASSERT_NE(pFile, nullptr);
|
|
(void)taosReadFile(pFile, readBuffer, size);
|
|
(void)taosCloseFile(&pFile);
|
|
int readLine = strlen(readBuffer);
|
|
ASSERT_EQ(size, readLine);
|
|
}
|
|
int64_t t3 = taosGetTimestampUs();
|
|
ReadFileCost = t3 - t2;
|
|
|
|
(void)printf("os file performance start open1...\n");
|
|
for (int i = 0; i < TESTTIMES; ++i) {
|
|
TdFilePtr pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_WRITE);
|
|
ASSERT_NE(pFile, nullptr);
|
|
(void)taosCloseFile(&pFile);
|
|
}
|
|
int64_t t4 = taosGetTimestampUs();
|
|
OpenForWriteCloseFileCost = t4 - t3;
|
|
|
|
(void)printf("os file performance start open2...\n");
|
|
for (int i = 0; i < TESTTIMES; ++i) {
|
|
TdFilePtr pFile = taosOpenFile(fname, TD_FILE_CREATE | TD_FILE_READ);
|
|
ASSERT_NE(pFile, nullptr);
|
|
(void)taosCloseFile(&pFile);
|
|
}
|
|
int64_t t5 = taosGetTimestampUs();
|
|
OpenForReadCloseFileCost = t5 - t4;
|
|
|
|
#ifdef WINDOWS
|
|
printf("os file performance start window native...\n");
|
|
for (int i = 0; i < TESTTIMES; ++i) {
|
|
HANDLE hFile = CreateFile(fname, // 文件名
|
|
GENERIC_WRITE, // 写权限
|
|
FILE_SHARE_READ, // 不共享
|
|
NULL, // 默认安全描述符
|
|
OPEN_ALWAYS, // 打开已存在的文件
|
|
FILE_FLAG_WRITE_THROUGH, // 文件标志，可以根据实际需求调整
|
|
NULL // 模板文件句柄，对于创建新文件不需要
|
|
);
|
|
|
|
if (hFile == INVALID_HANDLE_VALUE) {
|
|
printf("Error opening file\n");
|
|
break;
|
|
}
|
|
|
|
// 写入数据
|
|
DWORD bytesWritten;
|
|
if (!WriteFile(hFile, writeBuffer, size, &bytesWritten, NULL)) {
|
|
// 处理错误
|
|
printf("Error writing to file\n");
|
|
CloseHandle(hFile);
|
|
break;
|
|
}
|
|
// 关闭文件
|
|
CloseHandle(hFile);
|
|
}
|
|
int64_t t6 = taosGetTimestampUs();
|
|
int64_t nativeWritCost = t6 - t5;
|
|
|
|
printf("Test Write file using native API %d times, cost: %" PRId64 "us\n", TESTTIMES, nativeWritCost);
|
|
#endif // WINDOWS
|
|
|
|
taosMemoryFree(writeBuffer);
|
|
taosMemoryFree(readBuffer);
|
|
|
|
taosRemoveFile(fname);
|
|
|
|
(void)printf("Test Write file %d times, cost: %" PRId64 "us\n", TESTTIMES, WriteFileCost);
|
|
(void)printf("Test Read file %d times, cost: %" PRId64 "us\n", TESTTIMES, ReadFileCost);
|
|
(void)printf("Test OpenForWrite & Close file %d times, cost: %" PRId64 "us\n", TESTTIMES, OpenForWriteCloseFileCost);
|
|
(void)printf("Test OpenForRead & Close file %d times, cost: %" PRId64 "us\n", TESTTIMES, OpenForReadCloseFileCost);
|
|
}
|
|
|
|
#endif // OSFILE_PERFORMANCE_TEST
|
|
|
|
#pragma GCC diagnostic pop
|