//////////////////////////////////////////////////////////////////////////
///
/// net_cmd_proc
/// @author xuliang<*****@*****.**>
/// @date 2010-09-27
//////////////////////////////////////////////////////////////////////////
static void net_cmd_proc(ITSIP *p_net_head, NET_CONN_INFO *conn_info)
{
if (conn_info->client_conn < 1)
{
return;
}
if (p_net_head->itsip_head == ITS_HEAD)
{
switch(p_net_head->itsip_cmd)
{
case ITS_DOOR_ASK:
sys_print(FUNC, INFO, "==================CMD is door ask===================\n");
doorAsk(conn_info);
//doorAskAck(conn_info);
break;
case ITS_DOOR_OPEN:
doorOpen();
sys_print(FUNC, INFO, "==================CMD is door open===================\n");
break;
default:
sys_print(FUNC, WARN, "==================CMD is unknown[0x%.2x]===================\n", p_net_head->itsip_cmd);
break;
}
}
}
//////////////////////////////////////////////////////////////////////////
///
/// socket_cli_init
/// @author xuliang<*****@*****.**>
/// @date 2010-09-27
//////////////////////////////////////////////////////////////////////////
int socket_cli_init(DWORD ip, DWORD port)
{
int fd;
struct sockaddr_in addr;
fd = socket( AF_INET, SOCK_STREAM, 0 );
if (fd < 0)
{
perror("socket");
return fd;
}
bzero(&addr, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = (ip);
addr.sin_port = htons(port);
//连接目标相机
sys_print(FUNC, INFO, "it will connect to serv!\n");
if ( connect( fd, (const struct sockaddr *)&addr, sizeof(addr)) < 0 )
{
perror("connect timeout");
writeLog(LOG_ERROR, "连接服务器失败[%s]\n", sys_ip2str_static(ip));
close(fd);
return -1;
}
sys_print(FUNC, INFO, " connect to serv ok!\n");
writeLog(LOG_INFO, "连接服务器成功[%s]\n", sys_ip2str_static(ip));
return fd;
}
void
start(void)
{
int i;
for (i = 0; i < RUNCOUNT; i++) {
#ifndef __EXERCISE_8__
/* EXERCISE 6: use a system call to print characters *****************/
sys_print(PRINTCHAR);
#endif
#ifdef __EXERCISE_8__
/* EXERCISE 8: use a lock to prevent race conditions *****************/
// spinlock until we obtain write lock
while (atomic_swap(&spinlock, 1) != 0)
continue;
// write
*cursorpos++ = PRINTCHAR;
// release write lock
atomic_swap(&spinlock, 0);
#endif
sys_yield();
}
// Yield forever.
while (1)
sys_exit(0);
}
void
start(void)
{
sys_priority(PRIORITY);
sys_share(SHARE);
sys_yield();
int i;
for (i = 0; i < RUNCOUNT; i++) {
// Write characters to the console, yielding after each one.
//*cursorpos++ = PRINTCHAR;
//call system call instead
#ifndef __EXERCISE_8__
sys_print(PRINTCHAR);
#endif
#ifdef __EXERCISE_8__
while(atomic_swap(&spin_lock, 1) != 0){ //run 4ever until locked
continue;
}
*cursorpos++ = PRINTCHAR;
atomic_swap(&spin_lock, 0); //free
#endif
sys_yield();
}
// Yield forever.
while (1)
//sys_yield();
sys_exit(0);
}
void
start(void)
{
int i;
for (i = 0; i < RUNCOUNT; i++) {
// Write characters to the console, yielding after each one.
//*cursorpos++ = PRINTCHAR;
// Atomic syscall version
#ifdef __EXERCISE_6__
sys_print(PRINTCHAR);
#endif
// Atomic lock version
#ifdef __EXERCISE_8__
while (atomic_swap(&lock, 1) != 0)
continue;
*cursorpos++ = PRINTCHAR;
atomic_swap(&lock, 0);
#endif
sys_yield();
}
/*// Yield forever.
while (1)
sys_yield();*/
sys_exit(0);
}
void
start(void)
{
int i;
for (i = 0; i < RUNCOUNT; i++) {
// Write characters to the console, yielding after each one.
#ifndef __EXERCISE_8__
// (exercise 6 code)
sys_print(PRINTCHAR);
#else
// (exercise 8 code)
// Implemented spinlock to remove race condition of printing for each process.
while (atomic_swap(&spin_lock, 1) != 0)
continue;
*cursorpos++ = PRINTCHAR;
atomic_swap(&spin_lock, 0);
#endif
sys_yield();
}
sys_exit(0);
// // Yield forever.
// while (1)
// sys_yield();
}
static int sysprinttest(int arg)
{
char out = 'A'+arg;
for(int i=0; i<1<<10; i++) {
sys_print(&out, 1);
}
return 0;
}
int malloctest(int arg)
{
for(int i=0; i<1<<10; i++) {
if (arg==1) sys_print(".", 1);
void *tmp = malloc(i);
free(tmp);
}
return 0;
}
static void crouter_cfg_ident_print_xml(LOG *log, const UINT32 level)
{
UINT32 idx;
for(idx = 0; idx < level; idx ++)
{
sys_print(log, " ");
}
return;
}
void crouter_cfg_print_xml(LOG *log, const CROUTER_CFG *crouter_cfg, const UINT32 level)
{
crouter_cfg_ident_print_xml(log, level);
#if 1
sys_print(log, "<route src_tcid=\"%s\" des_tcid=\"%s\" next_hop=\"%s\" max_hops=\"%ld\"/>\n",
CROUTER_CFG_SRC_TCID_STR(crouter_cfg),
CROUTER_CFG_DES_TCID_STR(crouter_cfg),
CROUTER_CFG_NEXT_HOP_STR(crouter_cfg),
CROUTER_CFG_MAX_HOPS(crouter_cfg)
);
#endif
return;
}
void ex_ps1(void)
{
int i;
char msg[100];
for ( i = 0; i < 10; i++ )
{
sprintf(msg, "PS1's message: %d\n", i);
sys_print(msg);
sys_swtch(NULL);
}
sys_terminate(NULL);
}
int bartest1(int arg)
{
uint64_t count = 0;
char msg[128];
for(int i=0; i<1<<20; i++) {
BARRIER(barrier, NPROC);
count++;
}
// Take address of count to prevent optimisation
sprintf(msg, "%"PRIuCOREID": Count %"PRIx64" %p\n", disp_get_core_id(), count, &count);
sys_print(msg, strlen(msg));
return 0;
}
//////////////////////////////////////////////////////////////////////////
///
/// net_conn_close
/// @author xuliang<*****@*****.**>
/// @date 2010-09-27
//////////////////////////////////////////////////////////////////////////
void net_conn_close(NET_CONN_INFO *conn_info)
{
sys_print(FUNC, INFO, "网络连接 <%d> 关闭.\n", conn_info->conn_idx);
if (conn_info->client_conn > 0)
{
close(conn_info->client_conn);
conn_info->client_conn = -1;
conn_info->file_type = 0xff;
}
}
void
start(void)
{
int i;
for (i = 0; i < RUNCOUNT; i++) {
// Write characters to the console, yielding after each one.
sys_print(PRINTCHAR);
// *cursorpos++ = PRINTCHAR;
sys_yield();
}
sys_exit(0);
// Yield forever.
while (1)
sys_yield();
}
int inctest4(int arg)
{
uint64_t lcount = 0;
char msg[128];
for(int i=0; i<1<<20; i++) {
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
lcount++;
__sync_fetch_and_add(&atomiccounter, 1);
}
sprintf(msg, "%"PRIuCOREID": Count %"PRIx64" %p\n", disp_get_core_id(), lcount, &lcount);
sys_print(msg, strlen(msg));
return 0;
}
void chfsnprb_node_print_level(LOG *log, const CHFSNPRB_POOL *pool, const uint32_t node_pos, const uint32_t level)
{
const CHFSNPRB_NODE *node;
node = CHFSNPRB_POOL_NODE(pool, node_pos);
c_ident_print(log, level);
sys_print(log, "%5d: parent = %5d, left = %5d, right = %5d, flg = %s, color = %s, %s = %5d\n",
node_pos,
CHFSNPRB_NODE_PARENT_POS(node),
CHFSNPRB_NODE_LEFT_POS(node),
CHFSNPRB_NODE_RIGHT_POS(node),
CHFSNPRB_NODE_IS_USED(node) ? "used" : "NOT used",
CHFSNPRB_NODE_IS_RED(node) ? "red " : "black",
CHFSNPRB_NODE_IS_USED(node) ? "data" : "next",
CHFSNPRB_NODE_IS_USED(node) ? CHFSNPRB_NODE_DATA(node) : CHFSNPRB_NODE_NEXT_POS(node)
);
return;
}
void
start(void)
{
int i;
sys_priority(PRIORITY);
sys_proportion(PROPORTION);
for (i = 0; i < RUNCOUNT; i++) {
// Write characters to the console, yielding after each one.
#if CURRENT_PART == 1
*cursorpos++ = PRINTCHAR;
#endif
#if CURRENT_PART == 2
//first solution for synchronization
#ifndef EXTRA
while(atomic_swap(&lock,1))
continue;
*cursorpos++ = PRINTCHAR;
atomic_swap(&lock,0);
#endif
//second solution for synchronization
#ifdef EXTRA
sys_print((uint16_t)PRINTCHAR);
#endif
#endif
sys_yield();
}
sys_exit(0);
/*
// Yield forever.
while (1)
sys_yield();
*/
}
void
start(void)
{
int i;
sys_priority(MYPRIORITY);
sys_share(MYSHARE);
sys_ticket(TICKETS);
for (i = 0; i < RUNCOUNT; i++) {
// Write characters to the console, yielding after each one.
//*cursorpos++ = PRINTCHAR;
sys_print(PRINTCHAR);
sys_yield();
}
// Yield forever.
while (1)
sys_exit(0); // Exercise 2. Exit so don't yield forever. sys_exit needs an arg (int status)
}
void
start(void)
{
sys_share(USER_DEFINED_SHARE);
sys_priority(USER_DEFINED_PRIORITY);
int i;
for (i = 0; i < RUNCOUNT; i++) {
// Write characters to the console, yielding after each one.
if (MECHANISM == 0)
*cursorpos++ = PRINTCHAR;
else if (MECHANISM == 1) {
uint16_t *curpos = (uint16_t *)fetch_and_add((uint32_t *)&cursorpos,2);
*curpos = PRINTCHAR;
} else if (MECHANISM == 2)
sys_print(PRINTCHAR);
sys_yield();
}
// Yield forever.
sys_exit(1);
}
EC_BOOL lic_mac_collect(LIC_MAC *lic_mac_tbl, const UINT32 lic_mac_tbl_max_size, UINT32 *lic_mac_num)
{
int fd;
UINT32 net_interface;
struct ifreq buf[ LIC_INTERFACE_MAX_NUM ];
struct ifconf ifc;
UINT32 lic_mac_idx;
LIC_MAC *lic_mac;
lic_mac_idx = 0;
if ((fd = csocket_open(AF_INET, SOCK_DGRAM, 0)) >= 0)
{
ifc.ifc_len = sizeof(buf);
ifc.ifc_buf = (caddr_t) buf;
if (ioctl(fd, SIOCGIFCONF, (char *) &ifc))
{
close(fd);
return (EC_FALSE);
}
net_interface = sizeof(buf) / sizeof(buf[0]);
if(net_interface > lic_mac_tbl_max_size)
{
net_interface = lic_mac_tbl_max_size;
}
while (net_interface -- > 0)
{
/*Jugde whether the net card status is promisc */
if (ioctl(fd, SIOCGIFFLAGS, (char *) &buf[net_interface]))
{
continue;
}
if (!(buf[net_interface].ifr_flags & IFF_UP))
{
continue;
}
/*Get HW ADDRESS of the net card */
if (ioctl(fd, SIOCGIFHWADDR, (char *) &buf[net_interface]))
{
continue;
}
lic_mac = (lic_mac_tbl + lic_mac_idx);
#if 0
sys_log(stdout, "HW address is:");
sys_print(stdout, "%02x:%02x:%02x:%02x:%02x:%02x\n",
(unsigned char) buf[net_interface].ifr_hwaddr.sa_data[0],
(unsigned char) buf[net_interface].ifr_hwaddr.sa_data[1],
(unsigned char) buf[net_interface].ifr_hwaddr.sa_data[2],
(unsigned char) buf[net_interface].ifr_hwaddr.sa_data[3],
(unsigned char) buf[net_interface].ifr_hwaddr.sa_data[4],
(unsigned char) buf[net_interface].ifr_hwaddr.sa_data[5]);
#endif
LIC_MAC_ADDR(lic_mac, 0) = (UINT8)buf[net_interface].ifr_hwaddr.sa_data[0];
LIC_MAC_ADDR(lic_mac, 1) = (UINT8)buf[net_interface].ifr_hwaddr.sa_data[1];
LIC_MAC_ADDR(lic_mac, 2) = (UINT8)buf[net_interface].ifr_hwaddr.sa_data[2];
LIC_MAC_ADDR(lic_mac, 3) = (UINT8)buf[net_interface].ifr_hwaddr.sa_data[3];
LIC_MAC_ADDR(lic_mac, 4) = (UINT8)buf[net_interface].ifr_hwaddr.sa_data[4];
LIC_MAC_ADDR(lic_mac, 5) = (UINT8)buf[net_interface].ifr_hwaddr.sa_data[5];
lic_mac_idx ++;
}
}
close(fd);
(*lic_mac_num) = lic_mac_idx;
return (EC_TRUE);
}
//////////////////////////////////////////////////////////////////////////
///
/// net_svr_start
/// @author xuliang<*****@*****.**>
/// @date 2010-09-27
//////////////////////////////////////////////////////////////////////////
static void net_svr_start(NET_SERV_INFO *serv)
{
int flag = 0;
int ret = -1;
struct sockaddr_in server_addr;
int sndlen;
serv->fd = socket(AF_INET, SOCK_STREAM, 0);
if (serv->fd == -1)
{
perror("net_server_start: socket");
return;
}
// Enable address reuse and keeplive
flag = ON;
ret = setsockopt(serv->fd, SOL_SOCKET, SO_REUSEADDR, &flag, sizeof(flag));
if (ret == -1)
{
perror("net_server_start: setsockopt()");
return;
}
// Enable keeplive
ret = setsockopt(serv->fd, SOL_SOCKET, SO_KEEPALIVE, &flag, sizeof(flag));
if (ret == -1)
{
perror("net_server_start: setsockopt()");
return;
}
sndlen = 16 * 1024;
ret = setsockopt(serv->fd, SOL_SOCKET, SO_SNDBUF, &sndlen, sizeof(int));
if (ret == -1)
{
perror("net_server_start: setsockopt()");
return;
}
server_addr.sin_family = AF_INET;
server_addr.sin_addr.s_addr = INADDR_ANY;
server_addr.sin_port = htons(serv->port);
memset(server_addr.sin_zero, 0, sizeof(server_addr.sin_zero));
while (bind(serv->fd, (struct sockaddr *)&server_addr, sizeof(server_addr)) == -1)
{
perror("net_server_start: bind");
//close(g_listen_conn);
//return;
sleep(3);
}
if (listen(serv->fd, MAX_TCP_CONN) == -1)
{
perror("net_server_start: listen");
close(serv->fd);
return;
}
sys_print(FUNC, INFO, "等待网络连接......\n");
}
//////////////////////////////////////////////////////////////////////////
///
/// net_process
/// @author xuliang<*****@*****.**>
/// @date 2010-09-27
//////////////////////////////////////////////////////////////////////////
void net_process(void* arg)
{
int i;
int addr_size = 0;
int res = 0;
int client_sock = -1;
struct timeval tv;
struct sockaddr_in client_addr;
static int m_max_i = 0; //! max client connection number
static fd_set m_readfds; //! set of read socket handles
int m_max_sock = -1;
NET_INFO* door = (NET_INFO*)arg;
NET_CONN_INFO *conn = door->conn;
NET_SERV_INFO *serv = door->serv;
// while (1)
{
FD_ZERO(&m_readfds);
if (serv->fd > 0)
{
FD_SET(serv->fd, &m_readfds);
m_max_sock = serv->fd;
}
for ( i = 0; i < MAX_TCP_CONN; i++)
{
if (conn[i].client_conn < 0)
{
continue;
}
FD_SET(conn[i].client_conn, &m_readfds);
m_max_sock = m_max_sock > conn[i].client_conn ? m_max_sock : conn[i].client_conn;
}
tv.tv_sec = 0;
tv.tv_usec = 10000;
//res = select(m_max_sock + 1, &m_readfds, NULL, NULL, &tv);
res = select(m_max_sock + 1, &m_readfds, NULL, NULL, NULL);
if (res == 0)
{
return;
}
else if (res < 0)
{
if (errno == EINTR)
{
return;
}
perror("server_process: select");
//Close all client connections
for (i = 0; i < MAX_TCP_CONN; i++)
{
if (conn[i].client_conn > 0)
{
net_conn_close(&conn[i]);
}
}
return;
}
else if (res > 0)
{
if (FD_ISSET(serv->fd, &m_readfds))
{
addr_size = sizeof(client_addr);
client_sock = accept(serv->fd, (struct sockaddr *) & client_addr, &addr_size);
sys_print(FUNC, INFO, "++++++++++++++++++++新连接进入 %s.++++++++++++++++++++\n", inet_ntoa(client_addr.sin_addr));
if (client_sock > 0)
{
for (i = 0; i < MAX_TCP_CONN; i++)
{
if (conn[i].client_conn < 0)
{
conn[i].conn_idx = i;
conn[i].client_conn = client_sock;
conn[i].idle = 0;
strcpy(conn[i].clientip, inet_ntoa(client_addr.sin_addr));
if (i > m_max_i)
{
m_max_i = i;
}
break;
}
}
if (i == MAX_TCP_CONN)
{
close(client_sock);
client_sock = -1;
}
}
if (client_sock > m_max_sock)
{
m_max_sock = client_sock;
}
}
for (i = 0; i <= m_max_i; i++)
{
if (conn[i].client_conn < 0)
{
continue;
}
if (FD_ISSET(conn[i].client_conn, &m_readfds))
{
conn[i].idle = 0;
net_svr_proc(&conn[i]);
}
}
}
}
}
static void usage(char *p)
{
sys_print("usage: %s <command> <args>\n\n", p);
sys_print("standalone commands:\n");
sys_print(" start -p <port> -d <data.dir> -c <source.file>"
" -s <state.file>\n\n");
sys_print("distributed commands:\n");
sys_print(" tx -p <port> -c <source.file> -s <state.file>\n");
sys_print(" vol -p <port> -d <data.dir> -t <tx.host:port>\n");
sys_print(" exec -p <port> -t <tx.host:port>\n\n");
sys_print("program converter (v5 syntax):\n");
sys_print(
" convert - transforms v4 programs to the v5 syntax. the source program is\n");
sys_print(
" read from stdin and the result is printed to stdout. all identifiers\n");
sys_print(
" which clash with the new keywords will be prefixed with '___'. please\n");
sys_print(
" ensure that you review the resulting program.\n\n");
sys_die(VERSION);
}
//////////////////////////////////////////////////////////////////////////
///
/// net_conn_recv
/// @author xuliang<*****@*****.**>
/// @date 2010-09-27
//////////////////////////////////////////////////////////////////////////
int net_conn_recv(NET_CONN_INFO *conn_info, void *net_data, DWORD len)
{
BYTE *p_net_data = NULL;
int recv_cnt = 0;
int total_length = 0;
fd_set readfds;
int res = -1;
struct timeval tv;
UQWORD ms_cnt1 = 0LLU;
UQWORD ms_cnt2 = 0LLU;
UQWORD ms_cnt3 = 0LLU;
if (conn_info->client_conn <= 0)
{
return FAILURE;
}
p_net_data = net_data;
total_length = len;
ms_cnt1 = system_mscount_get();
while (1)
{
FD_ZERO(&readfds);
FD_SET(conn_info->client_conn, &readfds);
tv.tv_sec = 0;
tv.tv_usec = 1000;
res = select(conn_info->client_conn + 1, &readfds, NULL, NULL, &tv);
if (res < 0)
{
/*
* note by xuw 2007/03/02: for signal interrupt, do not close the socket, only continue.
*/
if (errno == EINTR)
{
continue;
}
perror("net_conn_recv:select");
net_conn_close(conn_info);
return FAILURE;
}
else if (res > 0)
{
if (FD_ISSET(conn_info->client_conn, &readfds))
{
recv_cnt = recv(conn_info->client_conn, p_net_data, total_length, MSG_DONTWAIT | MSG_NOSIGNAL);
ms_cnt1 = system_mscount_get();
}
}
else
{
ms_cnt2 = system_mscount_get();
//If the return value of select() is still Zero after 500ms, Close the socket
if (ms_cnt2 > ms_cnt1 && ms_cnt2 - ms_cnt1 >= TIMEOUT_CNT)
{
net_conn_close(conn_info);
sys_print(FUNC, ERROR, "客户端超过 %llu毫秒未响应, 必须关闭此次连接\n", ms_cnt2 - ms_cnt1);
writeLog(LOG_ERROR, "客户端超过 %llu毫秒未响应, 必须关闭此次连接\n", ms_cnt2 - ms_cnt1);
return FAILURE;
}
continue;
}
if (recv_cnt == -1)
{
perror("net_conn_recv:recv");
if (errno == ECONNRESET)
{
net_conn_close(conn_info);
}
return FAILURE;
}
if (recv_cnt == 0)
{
net_conn_close(conn_info);
return FAILURE;
}
if (total_length - recv_cnt == 0)
{
return SUCCESS;
}
else
{
ms_cnt3 = system_mscount_get();
//If the return value of select() is still Zero after 500ms, Close the socket
if (ms_cnt3 > ms_cnt1 && ms_cnt3 - ms_cnt1 >= TIMEOUT_CNT)
{
//We must close this socket and return FAILURE when the client is in problem.
//Otherwise system will stop to capture picture and video
net_conn_close(conn_info);
sys_print(FUNC, ERROR, "客户端发送错误，必须关闭此次连接\n");
return FAILURE;
}
p_net_data += recv_cnt;
total_length -= recv_cnt;
}
}
}
int main(int argc, char *argv[])
{
int nthreads = omp_get_max_threads();
if(argc == 2) {
nthreads = atoi(argv[1]);
backend_span_domain(nthreads, STACK_SIZE);
bomp_custom_init(NULL);
omp_set_num_threads(nthreads);
}
printf("threads %d, CPUs %d\n", nthreads, omp_get_num_procs());
volatile uint64_t exittime[ITERATIONS] = { 0 };
// Do some work
#pragma omp parallel
{
#ifdef GANG_SCHEDULING
bomp_synchronize();
#endif
for(int i = 0; i < ITERATIONS; i++) {
uint64_t start = rdtsc();
uint64_t workcn = 0;
for(uint64_t n = 0;; n++) {
#pragma omp barrier
workcn++;
if(omp_get_thread_num() == 0 && exittime[i] == 0
&& rdtsc() >= start + PERIOD) {
exittime[i] = n + 3;
}
if(exittime[i] != 0 && exittime[i] == n) {
n++;
break;
}
}
/* char buf[64]; */
/* sprintf(buf, "%d: %lu(%lu)\n", omp_get_thread_num(), workcn, */
/* stuck[omp_get_thread_num()]); */
/* sys_print(buf, strlen(buf)); */
/* stuck[omp_get_thread_num()] = 0; */
workcnt[omp_get_thread_num()][i] = workcn;
}
}
char buf[64];
for(int i = 0; i < ITERATIONS; i++) {
for(int n = 0; n < nthreads; n++) {
sprintf(buf, "%lu ", workcnt[n][i]);
sys_print(buf, strlen(buf));
}
sys_print("\n", 1);
}
/* sys_print("\n", 1); */
/* char buf[128], buf1[128]; */
/* sprintf(buf, "iterations in %lu ticks: ", PERIOD); */
/* for(int i = 0; i < nthreads; i++) { */
/* sprintf(buf1, "%lu ", workcnt[i]); */
/* strcat(buf, buf1); */
/* } */
/* sprintf(buf1, "\n"); */
/* strcat(buf, buf1); */
/* sys_print(buf, strlen(buf)); */
/* } */
for(;;);
return 0;
}
static int remote(void *dummy)
{
uint64_t time = rdtsc();
int core = disp_get_core_id();
times[core] = time;
printf("remote running on %d after %"PRIu64"\n", core, time-times[0]);
if (core == 1) sys_print("Null\n", 5);
BARRIER(barrier, NPROC);
//sys_print("*", 1);
null(core);
if (core == 1) sys_print("sys_print\n", 10);
BARRIER(barrier, NPROC);
sysprinttest(core);
BARRIER(barrier, NPROC);
if (core == 1) sys_print("terminal_write\n", 15);
BARRIER(barrier, NPROC);
termwritetest(core);
BARRIER(barrier, NPROC);
if (core == 1) sys_print("printf\n", 7);
BARRIER(barrier, NPROC);
printftest(core);
BARRIER(barrier, NPROC);
if (core == 1) sys_print("malloc\n", 7);
BARRIER(barrier, NPROC);
malloctest(core);
BARRIER(barrier, NPROC);
if (core == 1) printf("\nlocktest1\n");
gcount = 0;
BARRIER(barrier, NPROC);
locktest1(core);
BARRIER(barrier, NPROC);
if (core == 1) {
printf("gcount %"PRIx64"\n", gcount);
gcount = 0;
printf("locktest4\n");
}
BARRIER(barrier, NPROC);
locktest4(core);
BARRIER(barrier, NPROC);
if (core == 1) printf("gcount %"PRIx64"\n", gcount);
if (core == 1) printf("inctest1\n");
atomiccounter = 0;
BARRIER(barrier, NPROC);
inctest1(core);
BARRIER(barrier, NPROC);
if (core == 1) {
printf("count %"PRIx32"\n", atomiccounter);
atomiccounter = 0;
printf("inctest4\n");
}
BARRIER(barrier, NPROC);
inctest4(core);
BARRIER(barrier, NPROC);
if (core == 1) {
printf("count %"PRIx32"\n", atomiccounter);
atomiccounter = 0;
printf("bartest1\n");
}
BARRIER(barrier, NPROC);
bartest1(core);
BARRIER(barrier, NPROC);
if (core == 1) printf("bartest4\n");
BARRIER(barrier, NPROC);
bartest4(core);
BARRIER(barrier, NPROC);
if (core == 1) printf("mutextest\n");
BARRIER(barrier, NPROC);
mutextest(core);
BARRIER(barrier, NPROC);
if (core == 1) printf("Done\n");
return 0;
}
EC_BOOL test_case_82_crfs_read(const char *home, const UINT32 crfs_tcid, const UINT32 crfs_rank, const UINT32 crfs_modi, const UINT32 max_test_data_files, UINT32 *counter)
{
void *mod_mgr;
void *task_mgr;
UINT32 index;
CSTRING *path[CRFS_TEST_READ_MAX_FILES];
CBYTES *cbytes[CRFS_TEST_READ_MAX_FILES];/*read from dn*/
CBYTES *cbytes_des[CRFS_TEST_READ_MAX_FILES];/*benchmark*/
EC_BOOL ret[CRFS_TEST_READ_MAX_FILES];
EC_BOOL continue_flag;
for(index = 0; index < CRFS_TEST_READ_MAX_FILES; index ++)
{
path[ index ] = NULL_PTR;
cbytes[ index ] = NULL_PTR;
cbytes_des[ index ] = NULL_PTR;
ret[ index ] = EC_FALSE;
}
mod_mgr = mod_mgr_new(CMPI_ERROR_MODI, LOAD_BALANCING_LOOP);
mod_mgr_incl(crfs_tcid, CMPI_ANY_COMM, crfs_rank, crfs_modi, mod_mgr);
#if 0
sys_log(LOGSTDOUT, "test_case_82_crfs_read: npp mod mgr is\n");
mod_mgr_print(LOGSTDOUT, crfs_get_npp_mod_mgr(crfs_modi));
sys_log(LOGSTDOUT, "test_case_82_crfs_read: dn mod mgr is\n");
mod_mgr_print(LOGSTDOUT, crfs_get_dn_mod_mgr(crfs_modi));
#endif
task_mgr = task_new(mod_mgr, TASK_PRIO_NORMAL, TASK_NEED_RSP_FLAG, TASK_NEED_ALL_RSP);
for(index = 0; index < CRFS_TEST_READ_MAX_FILES; index ++, (*counter) ++)
{
path[ index ] = cstring_new(NULL_PTR, 0);
cstring_format(path[ index ], "%s/%ld.dat", home, (*counter));
cbytes[ index ] = cbytes_new(0);
cbytes_des[ index ] = __test_crfs_fetch_g_cbytes(max_test_data_files, ((*counter) % max_test_data_files));
ret[ index ] = EC_FALSE;
task_inc(task_mgr, &(ret[ index ]), FI_crfs_read, ERR_MODULE_ID, path[ index ], cbytes[ index ]);
}
task_wait(task_mgr, TASK_DEFAULT_LIVE, TASK_NEED_RESCHEDULE_FLAG, NULL_PTR);
continue_flag = EC_TRUE;
for(index = 0; index < CRFS_TEST_READ_MAX_FILES; index ++)
{
if(NULL_PTR != cbytes[ index ])
{
if(EC_TRUE == cbytes_ncmp(cbytes[ index ], cbytes_des[ index ], 16))
{
sys_log(LOGSTDOUT, "[SUCC] path: %s, len = %ld ",
(char *)cstring_get_str(path[ index ]),
cbytes_len(cbytes[ index ]));
sys_print(LOGSTDOUT, "text = %.*s\n",
cbytes_len(cbytes[ index ]) > 16 ? 16 : cbytes_len(cbytes[ index ]), /*output up to 16 chars*/
(char *)cbytes_buf(cbytes[ index ]));
}
else
{
continue_flag = EC_FALSE;
sys_log(LOGCONSOLE, "[FAIL] path: %s, read len = %ld ",
(char *)cstring_get_str(path[ index ]),
cbytes_len(cbytes[ index ]));
sys_print(LOGCONSOLE, "text = %.*s <--> ",
cbytes_len(cbytes[ index ]) > 16 ? 16 : cbytes_len(cbytes[ index ]), /*output up to 16 chars*/
(char *)cbytes_buf(cbytes[ index ]));
sys_print(LOGCONSOLE, "expect len = %ld ",
cbytes_len(cbytes_des[ index ]));
sys_print(LOGCONSOLE, "text = %.*s\n",
cbytes_len(cbytes_des[ index ]) > 16 ? 16 : cbytes_len(cbytes_des[ index ]),
(char *)cbytes_buf(cbytes_des[ index ]));
}
}
if(NULL_PTR != path[ index ])
{
cstring_free(path[ index ]);
path[ index ] = NULL_PTR;
}
if(NULL_PTR != cbytes[ index ])
{
cbytes_free(cbytes[ index ], 0);
cbytes[ index ] = NULL_PTR;
}
if(NULL_PTR != cbytes_des[ index ])
{
cbytes_des[ index ] = NULL_PTR;
}
}
mod_mgr_free(mod_mgr);
return (continue_flag);
}
