static struct threadrw_write_task *threadrw_buf_alloc_in(int num,
int block_size,
ssize_t (*write)(struct file *,
struct stream_buf_s *,
const char __user *, size_t, int))
{
int task_buffer_size = sizeof(struct threadrw_write_task) +
sizeof(struct threadrw_buf) * (num - 1) + 4;
struct threadrw_write_task *task = vmalloc(task_buffer_size);
int ret;
if (!task)
return NULL;
memset(task, 0, task_buffer_size);
spin_lock_init(&task->lock);
INIT_DELAYED_WORK(&task->write_work, do_write_work);
init_waitqueue_head(&task->wq);
ret = kfifo_alloc(&task->datafifo, num, GFP_KERNEL);
if (ret)
goto err1;
ret = kfifo_alloc(&task->freefifo, num, GFP_KERNEL);
if (ret)
goto err2;
task->write = write;
task->file = NULL;
task->buffer_size = 0;
ret = init_task_buffers(task, num, block_size);
if (ret < 0)
goto err3;
threadrw_wq_get(); /*start thread. */
return task;
err3:
kfifo_free(&task->freefifo);
err2:
kfifo_free(&task->datafifo);
err1:
vfree(task);
pr_err("alloc threadrw failed num:%d,block:%d\n", num, block_size);
return NULL;
}
int LdaExecutorInit::run(int32_t _num_iters) {
int suc;
int64_t accum_time = 0;
int64_t last_time = timer_st();
int64_t run_time;
if(exemode == ExeInitRun || exemode == ExeInitOnly) {
try {
extern_data_loader = new BufferManager(KNumExternDataBuffs*buffsize, buffsize, diskio);
} catch(...) {
return -1;
}
suc = task_buffer_mgr->init(internbase + ".task");
if(suc < 0) return -1;
suc = extern_data_loader->init_sequen_extern(extern_data_paths);
if(suc < 0) return -1;
suc = data_buffer_mgr->init(internbase + ".data");
if(suc < 0) return -1;
std::cout << "start initializing task buffers curr_time = " << accum_time << std::endl;
last_time = timer_st();
suc = init_task_buffers();
assert(suc == 0);
if(suc < 0) return -1;
run_time = timer_ed(last_time);
accum_time += run_time;
std::cout << "done initializing task buffers curr_time = " << accum_time << std::endl;
std::cout << "start initializing data buffers curr_time = " << accum_time << std::endl;
last_time = timer_st();
suc = init_data_buffers();
assert(suc == 0);
run_time = timer_ed(last_time);
accum_time += run_time;
std::cout << "done initializing data buffers curr_time = " << accum_time << std::endl;
if(suc < 0) return -1;
save_status();
if(exemode == ExeInitOnly) {
int32_t i;
for(i = 0; i < num_my_init_data_buffs; ++i) {
suc = data_buffer_mgr->putback(my_init_data_buffs[i], BufPolicyWriteBack);
assert(suc == 0);
}
for(i = 0; i < num_my_task_buffs; ++i) {
task_buffer_mgr->putback(my_task_buffs[i], BufPolicyWriteBack);
assert(suc == 0);
}
delete extern_data_loader;
extern_data_loader = NULL;
data_buffer_mgr->stop();
task_buffer_mgr->stop();
return 0;
}
delete extern_data_loader;
extern_data_loader = NULL;
data_buffer_mgr->stop();
task_buffer_mgr->stop();
}
int32_t num_task_iters = _num_iters;
if(num_my_task_buffs == num_total_task_buffs)
--num_task_iters;
if(_num_iters > 0) {
suc = task_buffer_mgr->init_sequen(internbase + ".task", num_my_task_buffs, _num_iters,
num_total_task_buffs);
assert(suc == 0);
std::cout << "task_buffer_mgr init_sequen done" << std::endl;
}
int32_t num_data_iters = (num_total_task_buffs + num_task_buffs - 1)/num_task_buffs;
suc = data_buffer_mgr->init_sequen(internbase + ".data", num_my_init_data_buffs,
num_data_iters*_num_iters, num_total_data_buffs);
assert(suc == 0);
std::cout << "start executing tasks curr_time = " << accum_time << std::endl;
int32_t iter;
for(iter = 0; iter < _num_iters; ++iter) {
last_time = timer_st();
suc = execute_all_tasks(iter);
if(suc < 0) return -1;
run_time = timer_ed(last_time);
accum_time += run_time;
std::cout << "executed iteration = " << iter << " curr_time = " << accum_time << std::endl;
}
data_buffer_mgr->stop();
task_buffer_mgr->stop();
return 0;
}
