int cpu_execute_request(sb_request_t *r, int thread_id)
{
unsigned long long c;
unsigned long long l;
double t;
unsigned long long n=0;
log_msg_t msg;
log_msg_oper_t op_msg;
(void)r; /* unused */
/* Prepare log message */
msg.type = LOG_MSG_TYPE_OPER;
msg.data = &op_msg;
/* So far we're using very simple test prime number tests in 64bit */
LOG_EVENT_START(msg, thread_id);
for(c=3; c < max_prime; c++)
{
t = sqrt((double)c);
for(l = 2; l <= t; l++)
if (c % l == 0)
break;
if (l > t )
n++;
}
LOG_EVENT_STOP(msg, thread_id);
return 0;
}
int mutex_execute_request(sb_request_t *sb_req, int thread_id)
{
unsigned int i;
unsigned int c=0;
unsigned int current_lock;
sb_mutex_request_t *mutex_req = &sb_req->u.mutex_request;
log_msg_t msg;
log_msg_oper_t op_msg;
/* Prepare log message */
msg.type = LOG_MSG_TYPE_OPER;
msg.data = &op_msg;
LOG_EVENT_START(msg, thread_id);
do
{
current_lock = rand() % mutex_num;
for (i = 0; i < mutex_req->nloops; i++)
c++;
pthread_mutex_lock(&thread_locks[current_lock].mutex);
global_var++;
pthread_mutex_unlock(&thread_locks[current_lock].mutex);
mutex_req->nlocks--;
}
while (mutex_req->nlocks > 0);
LOG_EVENT_STOP(msg, thread_id);
/* Perform only one request per thread */
return 1;
}
int sb_lua_op_execute_request(sb_request_t *sb_req, int thread_id)
{
log_msg_t msg;
log_msg_oper_t op_msg;
unsigned int restart;
lua_State *L = states[thread_id];
(void)sb_req; /* unused */
/* Prepare log message */
msg.type = LOG_MSG_TYPE_OPER;
msg.data = &op_msg;
LOG_EVENT_START(msg, thread_id);
do
{
restart = 0;
lua_getglobal(L, EVENT_FUNC);
lua_pushnumber(L, thread_id);
if (lua_pcall(L, 1, 1, 0))
{
if (lua_gettop(L) && lua_isnumber(L, -1) &&
lua_tonumber(L, -1) == SB_DB_ERROR_RESTART_TRANSACTION)
{
log_text(LOG_DEBUG,
"Ignored error encountered, restarting transaction");
restart = 1;
}
else
{
CALL_ERROR(L, EVENT_FUNC);
sb_globals.error = 1;
return 1;
}
}
lua_pop(L, 1);
} while (restart);
LOG_EVENT_STOP(msg, thread_id);
sb_percentile_update(&local_percentile, sb_timer_value(&timers[thread_id]));
return 0;
}
int threads_execute_request(sb_request_t *sb_req, int thread_id)
{
unsigned int i;
sb_threads_request_t *threads_req = &sb_req->u.threads_request;
log_msg_t msg;
log_msg_oper_t op_msg;
/* Prepare log message */
msg.type = LOG_MSG_TYPE_OPER;
msg.data = &op_msg;
LOG_EVENT_START(msg, thread_id);
for(i = 0; i < thread_yields; i++)
{
pthread_mutex_lock(&test_mutexes[threads_req->lock_num]);
YIELD();
pthread_mutex_unlock(&test_mutexes[threads_req->lock_num]);
}
LOG_EVENT_STOP(msg, thread_id);
return 0;
}
int memory_execute_request(sb_request_t *sb_req, int thread_id)
{
sb_mem_request_t *mem_req = &sb_req->u.mem_request;
int tmp = 0;
int idx;
int *buf, *end;
log_msg_t msg;
log_msg_oper_t op_msg;
long i;
unsigned int rand;
/* Prepare log message */
msg.type = LOG_MSG_TYPE_OPER;
msg.data = &op_msg;
if (mem_req->scope == SB_MEM_SCOPE_GLOBAL)
buf = buffer;
else
buf = buffers[thread_id];
end = (int *)((char *)buf + memory_block_size);
LOG_EVENT_START(msg, thread_id);
if (memory_access_rnd)
{
rand = sb_rnd();
switch (mem_req->type) {
case SB_MEM_OP_WRITE:
for (i = 0; i < memory_block_size; i++)
{
idx = (int)((double)rand / (double)SB_MAX_RND *
(double)(memory_block_size / sizeof(int)));
buf[idx] = tmp;
}
break;
case SB_MEM_OP_READ:
for (i = 0; i < memory_block_size; i++)
{
idx = (int)((double)rand / (double)SB_MAX_RND *
(double)(memory_block_size / sizeof(int)));
tmp = buf[idx];
}
break;
default:
log_text(LOG_FATAL, "Unknown memory request type:%d. Aborting...\n",
mem_req->type);
return 1;
}
}
else
{
switch (mem_req->type) {
case SB_MEM_OP_NONE:
for (; buf < end; buf++)
tmp = end - buf;
break;
case SB_MEM_OP_WRITE:
for (; buf < end; buf++)
*buf = tmp;
break;
case SB_MEM_OP_READ:
for (; buf < end; buf++)
tmp = *buf;
break;
default:
log_text(LOG_FATAL, "Unknown memory request type:%d. Aborting...\n",
mem_req->type);
return 1;
}
}
LOG_EVENT_STOP(msg, thread_id);
return 0;
}
int file_execute_request(sb_request_t *sb_req, int thread_id)
{
FILE_DESCRIPTOR fd;
sb_file_request_t *file_req = &sb_req->u.file_request;
log_msg_t msg;
log_msg_oper_t op_msg;
if (sb_globals.debug)
{
log_text(LOG_DEBUG,
"Executing request, operation: %d, file_id: %d, pos: %d, "
"size: %d",
file_req->operation,
file_req->file_id,
(int)file_req->pos,
(int)file_req->size);
}
/* Check request parameters */
if (file_req->file_id > num_files)
{
log_text(LOG_FATAL, "Incorrect file discovered in request");
return 1;
}
if (file_req->pos + file_req->size > file_size)
{
log_text(LOG_FATAL, "Too large position discovered in request!");
return 1;
}
fd = files[file_req->file_id];
/* Prepare log message */
msg.type = LOG_MSG_TYPE_OPER;
msg.data = &op_msg;
switch (file_req->operation) {
case FILE_OP_TYPE_NULL:
log_text(LOG_FATAL, "Execute of NULL request called !, aborting");
return 1;
case FILE_OP_TYPE_WRITE:
/* Store checksum and offset in a buffer when in validation mode */
if (sb_globals.validate)
file_fill_buffer(buffer, file_req->size, file_req->pos);
LOG_EVENT_START(msg, thread_id);
if(file_pwrite(file_req->file_id, buffer, file_req->size, file_req->pos,
thread_id)
!= (ssize_t)file_req->size)
{
log_errno(LOG_FATAL, "Failed to write file! file: " FD_FMT " pos: %lld",
fd, (long long)file_req->pos);
return 1;
}
/* Check if we have to fsync each write operation */
if (file_fsync_all)
{
if (file_fsync(file_req->file_id, thread_id))
{
log_errno(LOG_FATAL, "Failed to fsync file! file: " FD_FMT, fd);
return 1;
}
}
LOG_EVENT_STOP(msg, thread_id);
SB_THREAD_MUTEX_LOCK();
write_ops++;
real_write_ops++;
bytes_written += file_req->size;
if (file_fsync_all)
other_ops++;
SB_THREAD_MUTEX_UNLOCK();
break;
case FILE_OP_TYPE_READ:
LOG_EVENT_START(msg, thread_id);
if(file_pread(file_req->file_id, buffer, file_req->size, file_req->pos,
thread_id)
!= (ssize_t)file_req->size)
{
log_errno(LOG_FATAL, "Failed to read file! file: " FD_FMT " pos: %lld",
fd, (long long)file_req->pos);
return 1;
}
LOG_EVENT_STOP(msg, thread_id);
/* Validate block if run with validation enabled */
if (sb_globals.validate &&
file_validate_buffer(buffer, file_req->size, file_req->pos))
{
log_text(LOG_FATAL,
"Validation failed on file " FD_FMT ", block offset 0x%x, exiting...",
file_req->file_id, file_req->pos);
return 1;
}
SB_THREAD_MUTEX_LOCK();
read_ops++;
real_read_ops++;
bytes_read += file_req->size;
SB_THREAD_MUTEX_UNLOCK();
break;
case FILE_OP_TYPE_FSYNC:
/* Ignore fsync requests if we are already fsync'ing each operation */
if (file_fsync_all)
break;
if(file_fsync(file_req->file_id, thread_id))
{
log_errno(LOG_FATAL, "Failed to fsync file! file: " FD_FMT, fd);
return 1;
}
SB_THREAD_MUTEX_LOCK();
other_ops++;
SB_THREAD_MUTEX_UNLOCK();
break;
default:
log_text(LOG_FATAL, "Execute of UNKNOWN file request type called (%d)!, "
"aborting", file_req->operation);
return 1;
}
return 0;
}
