/** @todo add more */
} npuConstraint;
-#define DEFAULT_TIMEOUT (3000) /**< default timeout, 3000ms */
-#define DEFAULT_PRIORITY (NPU_PRIORITY_MID)
+static const uint32_t default_timeout = 3000;
+static const npu_priority default_priority = NPU_PRIORITY_MID;
/**
* @brief [OPTIONAL] Set the inference constraint for next NPU inferences
assert (data_size >= get_data_size (DATA_TYPE_SRNPU));
if (data_size > get_data_size (DATA_TYPE_SRNPU) ||
- !(zero_point == DEFAULT_ZERO_POINT && scale == DEFAULT_SCALE))
+ !(zero_point == default_zero_point && scale == default_scale))
need_quantization = true;
}
model_id_ = global_model_id_.fetch_add(1);
/** set default values */
- constraint_.timeout_ms = DEFAULT_TIMEOUT;
- constraint_.priority = DEFAULT_PRIORITY;
+ constraint_.timeout_ms = default_timeout;
+ constraint_.priority = default_priority;
in_.num_info = 1;
in_.info[0].layout = DATA_LAYOUT_SRNPU;
#include <assert.h>
/** this assumes uint8 zero quantization */
-#define DEFAULT_ZERO_POINT (127)
-#define DEFAULT_SCALE (1.0)
+static const uint32_t default_zero_point = 127;
+static const float default_scale = 1.0;
/**
* Here, the following is dependent to npubinfmt.h. So, this also follows
}
uint32_t getInputQuantZero (uint32_t idx) const override {
- return DEFAULT_ZERO_POINT;
+ return default_zero_point;
}
float getInputQuantScale (uint32_t idx) const override {
- return DEFAULT_SCALE;
+ return default_scale;
}
uint32_t getOutputQuantZero (uint32_t idx) const override {
- return DEFAULT_ZERO_POINT;
+ return default_zero_point;
}
float getOutputQuantScale (uint32_t idx) const override {
- return DEFAULT_SCALE;
+ return default_scale;
}
private:
void
Conf::reset ()
{
- setResvMemSize (std::to_string (DEFAULT_RESV_MEM_SIZE).c_str());
- setNumThreads (std::to_string (DEFAULT_NUM_THREADS).c_str());
- setLogDir (DEFAULT_LOG_DIR);
+ setResvMemSize (std::to_string (default_resv_mem_size).c_str());
+ setNumThreads (std::to_string (default_num_threads).c_str());
+ setLogDir (dafault_log_dir);
}
/**
#define MAX_DIR_LEN 256
-#define DEFAULT_LOG_DIR "/tmp/"
-#define DEFAULT_RESV_MEM_SIZE 0 /* default mode is the CMA allocation */
-#define DEFAULT_NUM_THREADS 8
-
#define ENV_LOG_DIR "NE_LOG_DIR"
#define ENV_RESV_MEM_SIZE "NE_RESV_MEM_SIZE"
#define ENV_NUM_THREADS "NE_NUM_THREADS"
+static const size_t default_resv_mem_size = 0; /* default mode is the CMA allocation */
+static const uint32_t default_num_threads = 8;
+static const char dafault_log_dir[] = "/tmp/";
+
/** @brief Configuration for NPU-Engine components */
class Conf {
public:
*/
TEST (ne_core_buffer_test, buffer_primitives)
{
+ const size_t exp_size_v1 = 4096;
+ const uint32_t exp_input_num_v1 = 1;
+ const uint32_t exp_output_num_v1 = 1;
std::unique_ptr<DriverAPI> api;
+
api = DriverAPI::createDriverAPI (NPUCOND_TRIV_CONN_SOCIP, 0);
ASSERT_NE (api.get(), nullptr);
std::unique_ptr<Buffer> buffer (new Buffer (new HWmemDevice));
buffer->setDriverAPI (api.get ());
- uint32_t size = 4096;
- EXPECT_EQ (buffer->alloc (size), 0);
- EXPECT_EQ (buffer->getSize (), size);
+ EXPECT_EQ (buffer->alloc (exp_size_v1), 0);
+ EXPECT_EQ (buffer->getSize (), exp_size_v1);
EXPECT_EQ (api.get(), buffer->getDriverAPI ());
/** it's okay even if metadata is nullptr */
EXPECT_EQ (buffer->createTensors (nullptr), 0);
- EXPECT_EQ (buffer->getInputNum (), 1);
- EXPECT_EQ (buffer->getOutputNum (), 1);
- EXPECT_EQ (buffer->getInputTensor (0)->getSize (), size);
- EXPECT_EQ (buffer->getOutputTensor (0)->getSize (), size);
+ EXPECT_EQ (buffer->getInputNum (), exp_input_num_v1);
+ EXPECT_EQ (buffer->getOutputNum (), exp_output_num_v1);
+ EXPECT_EQ (buffer->getInputTensor (0)->getSize (), exp_size_v1);
+ EXPECT_EQ (buffer->getOutputTensor (0)->getSize (), exp_size_v1);
npubin_meta data;
/** with metadata v1 */
std::unique_ptr<Metadata> meta = Metadata::extractMetadata (&data);
EXPECT_EQ (buffer->createTensors (meta.get()), 0);
- EXPECT_EQ (buffer->getInputNum (), 1);
- EXPECT_EQ (buffer->getOutputNum (), 1);
+ EXPECT_EQ (buffer->getInputNum (), exp_input_num_v1);
+ EXPECT_EQ (buffer->getOutputNum (), exp_output_num_v1);
EXPECT_EQ (buffer->getInputTensor (0)->getSize (), input_size);
EXPECT_EQ (buffer->getOutputTensor (0)->getSize (), output_size);
/** with metadata v2 */
- uint32_t input_num = 2;
- uint32_t output_num = 3;
- fill_test_metadata_v2 (data, input_num, output_num);
+ const uint32_t exp_input_num_v2 = 2;
+ const uint32_t exp_output_num_v2 = 3;
+ size_t exp_size_v2;
+
+ fill_test_metadata_v2 (data, exp_input_num_v2, exp_output_num_v2);
meta = Metadata::extractMetadata (&data);
- size = data.size;
+ exp_size_v2 = data.size;
std::unique_ptr<Buffer> buffer2 (new Buffer (new HWmemDevice));
buffer2->setDriverAPI (api.get ());
- EXPECT_EQ (buffer2->alloc (size), 0);
- EXPECT_EQ (buffer2->getSize (), size);
+ EXPECT_EQ (buffer2->alloc (exp_size_v2), 0);
+ EXPECT_EQ (buffer2->getSize (), exp_size_v2);
EXPECT_EQ (buffer2->createTensors (meta.get()), 0);
- EXPECT_EQ (buffer2->getInputNum (), input_num);
- EXPECT_EQ (buffer2->getOutputNum (), output_num);
+ EXPECT_EQ (buffer2->getInputNum (), exp_input_num_v2);
+ EXPECT_EQ (buffer2->getOutputNum (), exp_output_num_v2);
for (uint32_t i = 0; i < data.input_num; i++)
EXPECT_EQ (buffer2->getInputTensor (i)->getSize (),
data.num_called = 0;
EXPECT_EQ (device->run (opmode, model, &input_buf, user_cb, &data, &sequence), 0);
- EXPECT_EQ (sequence, 7); /* 7th run request */
+ EXPECT_EQ (sequence, (uint64_t) 7); /* 7th run request */
EXPECT_EQ (device->run (opmode, model, &input_buf, user_cb, &data, &sequence), 0);
- EXPECT_EQ (sequence, 8);
+ EXPECT_EQ (sequence, (uint64_t) 8);
EXPECT_EQ (device->run (opmode, model, &input_buf, user_cb, &data, &sequence), 0);
- EXPECT_EQ (sequence, 9);
+ EXPECT_EQ (sequence, (uint64_t) 9);
wait_callbacks (data.num_called, max_called, data.m, data.cv);
EXPECT_EQ (data.num_called, max_called);
create_model_buffer (model_buf);
EXPECT_EQ (handler->registerModel (&model_buf, &modelid_start), 0);
- EXPECT_GT (modelid_start, 0); /* starting from 1 */
+ EXPECT_GT (modelid_start, (uint32_t) 0); /* starting from 1 */
EXPECT_EQ (handler->registerModel (&model_buf, &modelid), 0);
EXPECT_EQ (modelid, modelid_start + 1); /* increasing by 1 */
EXPECT_EQ (handler->registerModel (&model_buf, &modelid), 0);
EXPECT_EQ (handler->unregisterModel (modelid_start + 2), 0);
EXPECT_EQ (handler->registerModel (&model_buf, &modelid_start), 0);
- EXPECT_GT (modelid_start, 0); /* starting from 1 */
+ EXPECT_GT (modelid_start, (uint32_t) 0); /* starting from 1 */
EXPECT_EQ (handler->registerModel (&model_buf, &modelid), 0);
EXPECT_EQ (modelid, modelid_start + 1); /* increasing by 1 */
EXPECT_EQ (handler->registerModel (&model_buf, &modelid), 0);
for (uint32_t i = 0; i < buf.num_buffers; i++) {
EXPECT_EQ (buf.bufs[i].dmabuf, buf.bufs[0].dmabuf);
- EXPECT_EQ (buf.bufs[i].offset, i * 0x1000);
- EXPECT_EQ (buf.bufs[i].size, 0x1000);
+ EXPECT_EQ (buf.bufs[i].offset, i * (uint64_t) 0x1000);
+ EXPECT_EQ (buf.bufs[i].size, (uint64_t) 0x1000);
EXPECT_EQ (buf.bufs[i].addr, static_cast<char *>(buf.bufs[0].addr) + i * 0x1000);
}
*/
TEST (ne_core_hwmem_test, hwmem_set_get_methods)
{
- INIT_TEST_DRIVER_API();
-
+ const size_t exp_size = 1024;
+ const size_t exp_offset = 0x1000;
HWmem *hwmem;
+ INIT_TEST_DRIVER_API();
+
/** testing set/get methods */
hwmem = new HWmem;
EXPECT_EQ (hwmem->getDmabuf(), 1);
hwmem->setDmabuf (-1);
EXPECT_EQ (hwmem->getDmabuf(), -1);
- hwmem->setSize (1024);
- EXPECT_EQ (hwmem->getSize(), 1024);
- hwmem->setOffset (0x1000);
- EXPECT_EQ (hwmem->getOffset(), 0x1000);
+ hwmem->setSize (exp_size);
+ EXPECT_EQ (hwmem->getSize(), exp_size);
+ hwmem->setOffset (exp_offset);
+ EXPECT_EQ (hwmem->getOffset(), exp_offset);
hwmem->setBaseAddr (hwmem);
EXPECT_EQ (hwmem->getBaseAddr(), hwmem);
hwmem->setBaseAddr (nullptr);
/** without setting driver APIs, all methods will be failed */
EXPECT_NE (hwmem->alloc (size), 0);
- EXPECT_EQ (hwmem->getSize (), 0);
+ EXPECT_EQ (hwmem->getSize (), (size_t) 0);
EXPECT_EQ (hwmem->getData (), nullptr);
EXPECT_NE (hwmem->dealloc (), 0);
/** size zero is ignored */
EXPECT_NE (hwmem->alloc (0), 0);
- EXPECT_EQ (hwmem->getSize (), 0);
+ EXPECT_EQ (hwmem->getSize (), (size_t) 0);
EXPECT_EQ (hwmem->getData (), nullptr);
EXPECT_NE (hwmem->dealloc (), 0);
* 'resv_mem_size' = 0: MemDefault.
*/
ASSERT_EQ (setenv ("NE_RESV_MEM_SIZE", "0", 1), 0);
- ASSERT_EQ (Conf::getInstance ().getResvMemSize (), 0);
+ ASSERT_EQ (Conf::getInstance ().getResvMemSize (), (size_t) 0);
std::unique_ptr<MemAllocator> mem = MemAllocator::createInstance (api.get ());
EXPECT_NE (mem.get (), nullptr);
/** 'resv_mem_size' > 0: MemPool (not implemented yet) */
ASSERT_EQ (setenv ("NE_RESV_MEM_SIZE", "2M", 1), 0);
- ASSERT_EQ (Conf::getInstance ().getResvMemSize (), 2 * M);
+ ASSERT_EQ (Conf::getInstance ().getResvMemSize (), (size_t) 2 * M);
std::unique_ptr<MemAllocator> mem = MemAllocator::createInstance (api.get ());
EXPECT_NE (mem.get (), nullptr);
*/
TEST (ne_core_model_test, model_primitives)
{
+ const uint32_t exp_num_tensors_v1 = 1;
+ const uint64_t exp_size_input = 2048;
+ const uint64_t exp_size_output = 2048;
std::unique_ptr <Model> model (new Model (new HWmemDevice));
- EXPECT_GT (model->getID (), 0);
+ EXPECT_GT (model->getID (), (uint32_t) 0);
/** make dummy metadata */
npubin_meta data;
data.magiccode = NPUBIN_MAGICCODE | 0x1; /* v1 */
data.size = 4096;
data.buffer_size = 4096;
- data.input_size = 2048;
+ data.input_size = exp_size_input;
data.input_offset = 0;
- data.output_size = 2048;
+ data.output_size = exp_size_output;
data.output_offset = 2048;
data.program_size = 0;
data.weight_size = 0;
EXPECT_EQ (model->setMetadata (&data), 0);
EXPECT_NE (model->getMetadata (), nullptr);
- EXPECT_EQ (model->getInputTensorNum (), 1); /* v1 has one input/output tensors */
- EXPECT_EQ (model->getOutputTensorNum (), 1);
+ EXPECT_EQ (model->getInputTensorNum (), exp_num_tensors_v1); /* v1 has one input/output tensors */
+ EXPECT_EQ (model->getOutputTensorNum (), exp_num_tensors_v1);
- EXPECT_EQ (model->getInputTensorSize (0), 2048);
- EXPECT_EQ (model->getOutputTensorSize (0), 2048);
+ EXPECT_EQ (model->getInputTensorSize (0), exp_size_input);
+ EXPECT_EQ (model->getOutputTensorSize (0),exp_size_output);
/** check default values */
npuConstraint constraint = model->getConstraint ();
- EXPECT_EQ (constraint.timeout_ms, DEFAULT_TIMEOUT);
- EXPECT_EQ (constraint.priority, DEFAULT_PRIORITY);
+ EXPECT_EQ (constraint.timeout_ms, default_timeout);
+ EXPECT_EQ (constraint.priority, default_priority);
const tensor_data_info * in = model->getInputDataInfo (0);
EXPECT_NE (in, nullptr);
constraint.timeout_ms = 100;
constraint.priority = NPU_PRIORITY_HIGH;
model->setConstraint (constraint);
- EXPECT_EQ (constraint.timeout_ms, 100);
- EXPECT_EQ (constraint.priority, NPU_PRIORITY_HIGH);
+ EXPECT_EQ (constraint.timeout_ms, model->getConstraint ().timeout_ms);
+ EXPECT_EQ (constraint.priority, model->getConstraint ().priority);
tensors_data_info in_info;
in_info.num_info = 2;
EXPECT_EQ (model->setDataInfo (&info, &info), 0);
EXPECT_EQ (model->getInputDataInfo (3), nullptr);
EXPECT_EQ (model->getOutputDataInfo (3), nullptr);
- EXPECT_EQ (model->getInputTensorSize (3), 0);
- EXPECT_EQ (model->getOutputTensorSize (3), 0);
+ EXPECT_EQ (model->getInputTensorSize (3), (uint32_t) 0);
+ EXPECT_EQ (model->getOutputTensorSize (3), (uint32_t) 0);
}
/**
/** access info without setting metadata */
EXPECT_EQ (model->getMetadata (), nullptr);
- EXPECT_EQ (model->getInputTensorSize (0), 0);
- EXPECT_EQ (model->getOutputTensorSize (0), 0);
+ EXPECT_EQ (model->getInputTensorSize (0), (uint32_t) 0);
+ EXPECT_EQ (model->getOutputTensorSize (0), (uint32_t) 0);
EXPECT_EQ (model->getInputDataInfo (0), nullptr);
EXPECT_EQ (model->getOutputDataInfo (0), nullptr);
}
/** make dummy metadata v1 */
npubin_meta data;
+ const uint32_t exp_meta_size_v1 = 4096;
+ const uint32_t exp_num_tensors_v1 = 1;
data.magiccode = NPUBIN_MAGICCODE | 0x1; /* v1 */
data.size = 8192;
EXPECT_NE (meta, nullptr);
EXPECT_EQ (meta->getVersion (), 1);
- EXPECT_EQ (meta->getSize (), 8192);
- EXPECT_EQ (meta->getBufferSize (), 4096);
- EXPECT_EQ (meta->getProgramSize (), 2048);
- EXPECT_EQ (meta->getWeightSize (), 2048);
- EXPECT_EQ (meta->getMetaSize (), 4096);
-
- EXPECT_EQ (meta->getInputNum (), 1);
- EXPECT_EQ (meta->getOutputNum (), 1);
- EXPECT_EQ (meta->getInputOffset (0), 1024);
- EXPECT_EQ (meta->getInputTensorSize (0, DATA_LAYOUT_SRNPU), 1024);
- EXPECT_EQ (meta->getOutputOffset (0), 2048);
- EXPECT_EQ (meta->getOutputTensorSize (0, DATA_LAYOUT_SRNPU), 2048);
+ EXPECT_EQ (meta->getSize (), data.size);
+ EXPECT_EQ (meta->getBufferSize (), data.buffer_size);
+ EXPECT_EQ (meta->getProgramSize (), data.program_size);
+ EXPECT_EQ (meta->getWeightSize (), data.weight_size);
+ EXPECT_EQ (meta->getMetaSize (), exp_meta_size_v1);
+
+ EXPECT_EQ (meta->getInputNum (), exp_num_tensors_v1);
+ EXPECT_EQ (meta->getOutputNum (), exp_num_tensors_v1);
+ EXPECT_EQ (meta->getInputOffset (0), data.input_offset);
+ EXPECT_EQ (meta->getInputTensorSize (0, DATA_LAYOUT_SRNPU), data.input_size);
+ EXPECT_EQ (meta->getOutputOffset (0), data.output_offset);
+ EXPECT_EQ (meta->getOutputTensorSize (0, DATA_LAYOUT_SRNPU), data.output_size);
/** return default values for unsupported info */
- EXPECT_EQ (meta->getInputElemSize (0), 1);
- EXPECT_EQ (meta->getOutputElemSize (0), 1);
+ EXPECT_EQ (meta->getInputElemSize (0), (uint32_t) 1);
+ EXPECT_EQ (meta->getOutputElemSize (0), (uint32_t) 1);
EXPECT_EQ (meta->getInputDims (0)[0], meta->getInputTensorSize (0, DATA_LAYOUT_SRNPU));
EXPECT_EQ (meta->getOutputDims (0)[0], meta->getOutputTensorSize (0, DATA_LAYOUT_SRNPU));
- EXPECT_EQ (meta->getInputQuantZero (0), DEFAULT_ZERO_POINT);
- EXPECT_EQ (meta->getOutputQuantZero (0), DEFAULT_ZERO_POINT);
- EXPECT_EQ (meta->getInputQuantScale (0), DEFAULT_SCALE);
- EXPECT_EQ (meta->getOutputQuantScale (0), DEFAULT_SCALE);
+ EXPECT_EQ (meta->getInputQuantZero (0), default_zero_point);
+ EXPECT_EQ (meta->getOutputQuantZero (0), default_zero_point);
+ EXPECT_FLOAT_EQ (meta->getInputQuantScale (0), default_scale);
+ EXPECT_FLOAT_EQ (meta->getOutputQuantScale (0), default_scale);
}
/**
EXPECT_NE (meta, nullptr);
EXPECT_EQ (meta->getVersion (), 2);
- EXPECT_EQ (meta->getBufferSize(), 4096);
- EXPECT_EQ (meta->getProgramSize(), 2048);
- EXPECT_EQ (meta->getWeightSize(), 2048);
+ EXPECT_EQ (meta->getBufferSize(), data.buffer_size);
+ EXPECT_EQ (meta->getProgramSize(), data.program_size);
+ EXPECT_EQ (meta->getWeightSize(), data.weight_size);
EXPECT_EQ (meta->getInputNum (), input_num);
for (uint32_t i = 0; i < meta->getInputNum (); i++) {
Request * req = new Request (NPUINPUT_HOST);
EXPECT_EQ (req->getOpmode (), NPUINPUT_HOST);
- EXPECT_GT (req->getID (), 0);
+ EXPECT_GT (req->getID (), (uint32_t) 0);
req->setModel (model.get ());
req->setBuffer (buffer.get ());
#include <poll.h>
#include <fstream>
+#include <string>
#include <ne-utils.h>
#include <ne-conf.h>
Conf & conf = Conf::getInstance ();
/** default configurations */
- EXPECT_EQ (conf.getResvMemSize(), DEFAULT_RESV_MEM_SIZE);
- EXPECT_EQ (conf.getNumThreads(), DEFAULT_NUM_THREADS);
- EXPECT_STREQ (conf.getLogDir(), DEFAULT_LOG_DIR);
+ EXPECT_EQ (conf.getResvMemSize(), default_resv_mem_size);
+ EXPECT_EQ (conf.getNumThreads(), default_num_threads);
+ EXPECT_STREQ (conf.getLogDir(), dafault_log_dir);
restore_envvars (envvars);
}
*/
TEST (ne_core_utils_test, load_conf_ini)
{
+ const char test_ini_file[] = "dummy.ini";
+ const char exp_log_dir[] = "/tmp/test_log";
+ const uint32_t exp_num_threads = 4;
+ const size_t exp_rsv_mem_sizek = 128;
+ const size_t exp_rsv_mem_sizeb = exp_rsv_mem_sizek * 1024;
ENV_PAIR envvars;
+ std::ofstream ofs;
+
save_and_unset_envvars (envvars);
- /** make dummy .ini file */
- std::ofstream ofs ("dummy.ini");
+ /** make dummy .ini file */
+ ofs = std::ofstream (test_ini_file);
ASSERT_EQ (ofs.good(), true);
ofs << "[main]\n";
- ofs << "resv_mem_size=128k\n";
- ofs << "num_threads=4\n";
- ofs << "log_dir=/tmp/test_log\n";
+ ofs << "resv_mem_size="<<exp_rsv_mem_sizek<<"k"<<std::endl;
+ ofs << "num_threads="<<exp_num_threads<<std::endl;
+ ofs << "log_dir="<<exp_log_dir<<std::endl;
ofs.close();
- Conf & conf = Conf::getInstance ("dummy.ini");
+ Conf & conf = Conf::getInstance (test_ini_file);
- EXPECT_EQ (conf.getResvMemSize(), 128 * 1024);
- EXPECT_EQ (conf.getNumThreads(), 4);
- EXPECT_STREQ (conf.getLogDir(), "/tmp/test_log");
+ EXPECT_EQ (conf.getResvMemSize(), exp_rsv_mem_sizeb);
+ EXPECT_EQ (conf.getNumThreads(), exp_num_threads);
+ EXPECT_STREQ (conf.getLogDir(), exp_log_dir);
conf.reset ();
restore_envvars (envvars);
conf = Conf::getInstance ("dummy.ini");
/** still default configurations */
- EXPECT_EQ (conf.getResvMemSize(), DEFAULT_RESV_MEM_SIZE);
- EXPECT_EQ (conf.getNumThreads(), DEFAULT_NUM_THREADS);
- EXPECT_STREQ (conf.getLogDir(), DEFAULT_LOG_DIR);
+ EXPECT_EQ (conf.getResvMemSize(), default_resv_mem_size);
+ EXPECT_EQ (conf.getNumThreads(), default_num_threads);
+ EXPECT_STREQ (conf.getLogDir(), dafault_log_dir);
conf.reset ();
restore_envvars (envvars);
*/
TEST (ne_core_utils_test, load_conf_env)
{
+ const char exp_log_dir[] = "/tmp/";
+ const uint32_t exp_num_threads = 16;
+ const size_t exp_rsv_mem_sizeg = 1;
+ const size_t exp_rsv_mem_sizeb = exp_rsv_mem_sizeg * 1024 * 1024 * 1024;
+ const std::string exp_str_rsv_mem_sizeg (std::to_string(exp_rsv_mem_sizeg) + "G");
+ const std::string exp_str_num_threads (std::to_string(exp_num_threads));
ENV_PAIR envvars;
save_and_unset_envvars (envvars);
- EXPECT_EQ (setenv("NE_RESV_MEM_SIZE", "1G", 1), 0);
- EXPECT_EQ (setenv("NE_NUM_THREADS", "16", 1), 0);
- EXPECT_EQ (setenv("NE_LOG_DIR", "/tmp/", 1), 0);
+ EXPECT_EQ (setenv("NE_RESV_MEM_SIZE", exp_str_rsv_mem_sizeg.c_str(), 1), 0);
+ EXPECT_EQ (setenv("NE_NUM_THREADS", exp_str_num_threads.c_str(), 1), 0);
+ EXPECT_EQ (setenv("NE_LOG_DIR", exp_log_dir, 1), 0);
Conf & conf = Conf::getInstance ();
- EXPECT_EQ (conf.getResvMemSize(), 1024 * 1024 * 1024);
- EXPECT_EQ (conf.getNumThreads(), 16);
- EXPECT_STREQ (conf.getLogDir(), "/tmp/");
+ EXPECT_EQ (conf.getResvMemSize(), exp_rsv_mem_sizeb);
+ EXPECT_EQ (conf.getNumThreads(), exp_num_threads);
+ EXPECT_STREQ (conf.getLogDir(), exp_log_dir);
conf.reset ();
restore_envvars (envvars);
Conf & conf = Conf::getInstance ();
/** still default configurations */
- EXPECT_EQ (conf.getResvMemSize(), DEFAULT_RESV_MEM_SIZE);
- EXPECT_EQ (conf.getNumThreads(), DEFAULT_NUM_THREADS);
- EXPECT_STREQ (conf.getLogDir(), DEFAULT_LOG_DIR);
+ EXPECT_EQ (conf.getResvMemSize(), default_resv_mem_size);
+ EXPECT_EQ (conf.getNumThreads(), default_num_threads);
+ EXPECT_STREQ (conf.getLogDir(), dafault_log_dir);
conf.reset ();
restore_envvars (envvars);
projects / platform / adaptation / npu / trix-engine.git / commitdiff