int main(int argc, char **argv) {
size_t prefix_len;
FILE *current_nodes, *current_node_tags, *nodes, *node_tags;
char *tempfn;
struct data data, *d = &data;
if (argc != 8) {
printf("Usage: 019_populate_node_tags_and_remove_helper host user passwd database port socket prefix\n");
exit(EXIT_FAILURE);
}
d->mysql = connect_to_mysql(argv);
d->version_size = 1 + select_size(d->mysql, "SELECT max(id) FROM current_nodes");
d->version = (uint16_t *) malloc(sizeof(uint16_t) * d->version_size);
if (!d->version) {
perror("malloc");
abort();
exit(EXIT_FAILURE);
}
memset(d->version, 0, sizeof(uint16_t) * d->version_size);
prefix_len = strlen(argv[7]);
tempfn = (char *) malloc(prefix_len + 32);
strcpy(tempfn, argv[7]);
strcpy(tempfn + prefix_len, "current_nodes");
open_file(¤t_nodes, tempfn);
strcpy(tempfn + prefix_len, "current_node_tags");
open_file(¤t_node_tags, tempfn);
strcpy(tempfn + prefix_len, "nodes");
open_file(&nodes, tempfn);
strcpy(tempfn + prefix_len, "node_tags");
open_file(&node_tags, tempfn);
free(tempfn);
proc_nodes(d, "nodes", nodes, node_tags, 1);
proc_nodes(d, "current_nodes", current_nodes, current_node_tags, 0);
free(d->version);
mysql_close(d->mysql);
fclose(current_nodes);
fclose(current_node_tags);
fclose(nodes);
fclose(node_tags);
exit(EXIT_SUCCESS);
}
void *workload_replayer(void *arg)
{
unsigned int tid = 0;
readLine req;
long long trace_sTime = -1;
long long trace_wTime = 0;
long long gio_sTime = 0;
long long gio_wTime = 0;
struct timeval now;
int fd;
char *buf;
size_t ret;
unsigned long mSize;
unsigned long mAddr;
OPERATION_TYPE op;
desc = (wg_env *)arg;
if( (fd = open(desc->file_path, O_CREAT|O_RDWR|O_DIRECT, 0666)) == -1 ){
//if( (fd = open(desc->file_path, O_CREAT|O_RDWR, 0666)) == -1){
PRINT("Error on opening the init_file of workload generator, file:%s, line:%d, fd=%d\n", __func__, __LINE__, fd);
exit(1);
}
#if !defined(BLOCKING_IO)
aio_initialize(desc->max_queue_depth);
#endif
mem_allocation(desc, &buf, REPLAYER_MAX_FILE_SIZE);
if (NULL == buf) {
PRINT("Error on memory allocation, file:%s, line:%d\n", __func__, __LINE__);
exit(1);
}
while(1){
//Dequeueing
req = de_queue();
//If a request is successfully dequeued.
if(strcmp(req.rwbs, "EMPTY") != 0){
mSize = select_size(req.size);
mAddr = select_start_addr(req.sSector);
fill_data(desc, buf, mSize);
//Calculate wait time based on trace log
if(trace_sTime == -1){
get_start_time(&trace_sTime, &gio_sTime);
}
trace_wTime = MICRO_SECOND(req.sTime) - trace_sTime;
if(trace_wTime < 0){
PRINT("trace_wTime : %lli\n", trace_wTime);
PRINT("Issue time must be ordered. Check the issue time in trace file");
exit(1);
}
//Caculate how much time should wait
get_current_time(&now);
gio_wTime = TIME_VALUE(&now) - gio_sTime;
PRINT("TIMEDEBUG trace_wTime:%10lli \tgio_wTime:%10lli\n",
trace_wTime, gio_wTime);
//If we need to wait
if(trace_wTime > gio_wTime){
PRINT("WAITING ....%lli us\n", trace_wTime - gio_wTime);
usec_sleep(trace_wTime - gio_wTime);
}
op = strstr(req.rwbs,"R")!=NULL? WG_READ : WG_WRITE;
#if defined(BLOCKING_IO)
if(op == WG_READ){
//PRINT("R\n");
ret = pread(fd, buf , (size_t)mSize, mAddr);
}else{
//PRINT("W\n");
ret = pwrite(fd, buf , (size_t)mSize, mAddr);
fsync(fd);
}
if (ret != mSize) {
PRINT("Error on file I/O (error# : %zu), file:%s, line:%d\n", ret, __func__, __LINE__);
break;
}
#else
ret = aio_enqueue(fd, buf, mSize, mAddr, op);
if (ret != 1) {
PRINT("Error on file I/O (error# : %zu), file:%s, line:%d\n", ret, __func__, __LINE__);
break;
}
#endif //BLOCKING_IO
#if 0
PRINT("DEQUEUED REQ tid:%u sTime:%lf rwbs:%s Addr:%12li \t Size:%12lu\n\n",
tid,
req.sTime,
req.rwbs,
mAddr,
mSize);
#endif
}
if( get_queue_status() == 1 ){
PRINT("END OF REPLAYER\n");
break;
}
}
pthread_mutex_destroy(&thr_mutex);
}
