/*================================MAIN FUNCTION====================================*/
int main()
{
thread_pool_t* thread_pool;
common_msg_t common_msg;
//syn_queue_t* queue_syn;
int i;
//log_init("/home/binyang/Program/filesystem/src/common/test", LOG_DEBUG);
log_init("", LOG_DEBUG);
queue_syn = alloc_syn_queue(10, sizeof(common_msg_t));
thread_pool = alloc_thread_pool(8, queue_syn, resolve_handler);
thread_pool->tp_ops->start(thread_pool);
for(i = 0; i < 30; i++)
{
common_msg.operation_code = 1;
queue_syn->op->syn_queue_push(queue_syn, &common_msg);
common_msg.operation_code = 2;
queue_syn->op->syn_queue_push(queue_syn, &common_msg);
}
destroy_thread_pool(thread_pool);
destroy_syn_queue(queue_syn);
log_close();
return 0;
}
DISPATCHER_NAMESPACE_BEGIN
CDispatcherContext::~CDispatcherContext()
{
destroy_thread_pool();
// 要晚于线程被删除，因为在线程被停止前，可能仍在被使用
delete _managed_sender_table;
delete _unmanaged_sender_table;
}
void test_mm(void) {
int max_threads = 8;
thread_pool_t *thread_pool = create_thread_pool(max_threads);
int m = 8192;
int n = 1024;
int k = 1024;
double *a = make_array(m, k);
double *b = make_array(k, n);
double *o = make_array(m, n);
int tile_sizes[5] = {1024, 64, 64, 8, 8};
int num_threads = 8;
job_t *job = make_job(0, m, 1024, num_threads, 1);
vm_args_t vm_args;
vm_args.a = a;
vm_args.b = b;
vm_args.out = o;
vm_args.m = m;
vm_args.n = n;
vm_args.k = k;
struct timeval start, end, result;
gettimeofday(&start, NULL);
launch_job(thread_pool, &vm2, &vm_args, job, tile_sizes, 1);
wait_for_job(thread_pool);
gettimeofday(&end, NULL);
double t;
timersub(&end, &start, &result);
t = result.tv_sec + result.tv_usec / 1000000.0;
printf("Parallel runtime: %f\n", t);
int pass = 1;
// int i, j, l;
// double sum;
// gettimeofday(&start, NULL);
// for (i = 0; i < m; ++i) {
// for (j = 0; j < n; ++j) {
// sum = 0.0;
// for (l = 0; l < k; ++l) {
// sum += a[i*k + l] * b[j*k + l];
// }
// pass = pass && (abs(sum - o[i*n + j]) < 1e-4);
// }
// }
// gettimeofday(&end, NULL);
CU_ASSERT(pass);
// double naive_time;
// timersub(&end, &start, &result);
// naive_time = result.tv_sec + result.tv_usec / 1000000.0;
// printf("Naive time: %f\n", naive_time);
destroy_thread_pool(thread_pool);
free_job(job);
free_array(a);
free_array(b);
free_array(o);
}
int main(int argc, char* argv[])
{
if (argc <= 2)
{
printf("Usage: %s ip_address port_number\n", argv[0]);
return 0;
}
log_globals_init(&g_log);
log_init(&g_log, "jhttpserver.log", NULL);
log_set_loglevel(&g_log, LOG_DEBUG);
const char* ip = argv[1];
int port = atoi(argv[2]);
INFO(&g_log, "jhttpserver", "%s : %d", ip, port);
add_signal(SIGPIPE, SIG_IGN, TRUE);
thread_pool* pool = create_thread_pool(8 ,10000);
if (pool == NULL)
{
printf("create thread pool is failed.");
ERROR(&g_log, "jhttpserver", "create thread pool is failed.");
return 1;
}
http_conn* users = (http_conn*)malloc(sizeof(http_conn) * MAX_FD);
assert(users);
int listen_fd = socket(PF_INET, SOCK_STREAM, 0);
struct linger tmp = {1, 0};
setsockopt(listen_fd, SOL_SOCKET, SO_LINGER, &tmp, sizeof(tmp));
int ret = 0;
struct sockaddr_in address;
bzero(&address, sizeof(address));
address.sin_family = AF_INET;
address.sin_port = htons(port);
inet_pton(AF_INET, ip, &address.sin_addr);
ret = bind(listen_fd, (struct sockaddr *)&address, sizeof(address));
assert(ret >= 0);
ret = listen(listen_fd, 5);
assert(ret >= 0);
struct epoll_event events[MAX_EVENT_NUMBER];
epollfd = epoll_create(5);
assert(epollfd != -1);
add_fd(epollfd, listen_fd, false);
while (true)
{
int number = epoll_wait(epollfd, events, MAX_EVENT_NUMBER, -1);
if ((number < 0) && (errno != EINTR))
{
printf("epoll failure\n");
break;
}
int i=0;
for (; i<number; i++)
{
int sockfd = events[i].data.fd;
if (sockfd == listen_fd)
{
struct sockaddr_in client_address;
socklen_t client_addr_len = sizeof(client_address);
int conn_fd = accept(listen_fd, (struct sockaddr*)&client_address,
&client_addr_len);
if (conn_fd < 0)
{
printf("errno is : %d\n", errno);
continue;
}
if (user_count > MAX_FD)
{
show_error(conn_fd, "Internal server busy");
continue;
}
init_new_connect(&users[conn_fd], conn_fd, &client_address);
}
else if (events[i].events & (EPOLLRDHUP | EPOLLHUP | EPOLLERR))
{
close_connect(&users[sockfd]);
}
else if (events[i].events & EPOLLIN)
{
if (http_conn_read(&users[sockfd]))
{
add_conn(pool, users + sockfd);
}
else
{
close_connect(&users[sockfd]);
}
}
else if (events[i].events & EPOLLOUT)
{
if (!http_conn_write(&users[sockfd]))
{
close_connect(&users[sockfd]);
}
}
}
}
close(epollfd);
close(listen_fd);
free(users);
destroy_thread_pool(pool);
return 0;
}
