int main(void)
{
int i;
srand(time(NULL));
concurrent_init();
for (i = 0; i < 1000; i++) {
int stack_size = 1024 + 16 + (rand() % 16);
int torture_offset = rand() % 16;
ConcurrentContext *context;
unsigned char *stack;
ConcurrentStatus status;
context = malloc(ctx_sizeof());
stack = malloc(sizeof(*stack) * stack_size);
status = ctx_construct(context,
stack + torture_offset,
stack_size - torture_offset,
test_generator, NULL);
assert(status == ConcurrentStatus_SUCCESS);
assert(strcmp(gen_str(context), "pong") == 0);
ctx_destruct(context);
free(stack);
free(context);
}
concurrent_fin();
return 0;
}
void
init_key(int nbuckets) {
for (int i = 0; i < KEY_NUM; i++) {
gen_str(keys[i].key_str, i);
keys[i].count = keys[i].get_count = keys[i].update_count = 0;
keys[i].syndrome = 10000 + i;
keys[i].bucket = i % nbuckets;
printf("key[%d]=%s\n", i, keys[i].key_str);
}
}
int main(int argc, char* argv[])
{
srand(time(NULL));
int fd = socket(AF_INET, SOCK_STREAM, 0);
if (fd == -1) {
printf("%s\n", strerror(errno));
}
struct sockaddr_in servaddr;
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(11000);
inet_pton(AF_INET, "127.0.0.1", &servaddr.sin_addr);
int ret = connect(fd, (struct sockaddr *)&servaddr, sizeof(struct sockaddr));
if (ret == -1) {
printf("%s", strerror(errno));
return 0;
}
int epfd = epoll_create(1024);
if (epfd == -1) {
printf("create failed");
return 0;
}
set_io_nonblock(fd, 1);
struct epoll_event event;
event.data.fd = fd;
event.events = EPOLLIN | EPOLLET;
ret = epoll_ctl(epfd, EPOLL_CTL_ADD, fd, &event);
struct epoll_event *evs = (struct epoll_event *)malloc(sizeof(struct epoll_event) * 200);
int done = 0;
while (!done) {
int i;
recv_again:
int n = epoll_wait(epfd, evs, 1024, 100);
if (n == -1 && errno != EINTR) {
printf("%s", strerror(errno));
return 0;
}
for (i = 0; i < n; ++i) {
int fd = evs[i].data.fd;
printf("fd=%u type=%u\n", fd, evs[i].events);
if (evs[i].events && EPOLLIN) {
char recvbuf[102400];
int ret = safe_tcp_recv_n(fd, recvbuf, 102400);
if (ret == 0) {
printf("fd closed");
return 0;
} else if (ret > 0) {
printf("recvbuf len=%d\n", ret);
int len = ret;
int readlen = 0;
struct timeval end;
struct timeval start;
while (readlen < len) {
gettimeofday(&end, NULL);
char* ptr = recvbuf;
proto_pkg_t *msg = (proto_pkg_t *)(ptr + readlen);
start = seq_time_map[msg->seq];
printf("recv: %d,%d,%d,%d,%d,%s:%lu,%lu\n",
msg->id,
msg->cmd,
msg->seq,
msg->ret,
msg->len,
msg->data,
msg->len - sizeof(proto_pkg_t),
(end.tv_sec - start.tv_sec) * 1000000 + (end.tv_usec - start.tv_usec)
);
readlen += msg->len;
seq_time_map.erase(msg->seq);
}
} else {
printf("recv error");
return 0;
}
} else if (evs[i].events && EPOLLOUT) {
}
}
if (seq_time_map.size()) {
goto recv_again;
}
sleep(1);
//getchar();
char input[200] = {'\0'};
int num = rand() % 200+ 1;
//int num = 30;
gen_str(input, num);
// scanf("%s", input);
char buf[1024];
for (i = 0; i < 200; ++i) {
proto_pkg_t *pkg = (proto_pkg_t *)buf;
pkg->id = i;
pkg->cmd = i + 1;
pkg->ret = i + 2;
pkg->seq = ++seq;
struct timeval start;
gettimeofday(&start, NULL);
seq_time_map[pkg->seq] = start;
pkg->len = sizeof(proto_pkg_t) + strlen(input) + 1;
input[strlen(input)] = '\0';
memcpy(pkg->data, input, strlen(input) + 1);
send(fd, buf, pkg->len, 0);
printf("send: id=%u,cmd=%u,seq=%u,ret=%u,%s:%lu\n\n", pkg->id, pkg->cmd, pkg->seq, pkg->ret, input, strlen(input) + 1);
// getchar();
}
// sleep(1);
//if (rand() % 2) {
//}
}
free(evs);
close(epfd);
close(fd);
return 0;
}
void threadTest(uint64_t arg) {
int maxtop = 16;
int top = 16;
int nbuckets = hashsize(4);
int loops = NCANDIDATES;
int mm_size;
void *buf;
struct _key keys[NCANDIDATES];
struct _key big_key, small_key;
char *recv = (char *) plat_alloc(300*top);
if (recv == NULL) {
perror("failed to alloc");
}
mm_size = calc_hotkey_memory(maxtop, nbuckets, 0);
buf = plat_alloc(mm_size);
Reporter_t *rpt;
for (int i = 0; i < NCANDIDATES; i++) {
gen_str(keys[i].key_str);
keys[i].syndrome = 10000 + i;
keys[i].bucket = i % 4;
}
gen_str(big_key.key_str);
big_key.syndrome = 10000 + NCANDIDATES - 1;
big_key.bucket = (NCANDIDATES - 1) % 4;
gen_str(small_key.key_str);
small_key.syndrome = 10000 + 65536;
small_key.bucket = (NCANDIDATES - 1) % 4;
rpt = hot_key_init(buf, mm_size, nbuckets, maxtop, 0);
int ip = 127001;
for (int i = 0; i < 2; i++) {
loops = NCANDIDATES;
while (loops--) {
hot_key_update(rpt, keys[loops].key_str, KEY_LEN + 1,
keys[loops].syndrome, keys[loops].bucket,
1 + random()%11, ip);
}
}
hot_key_report(rpt, top, recv, 300*top, 1, 0);
printf("keys:\n%s", recv);
loops = NCANDIDATES;
while (loops--) {
if (!strstr(recv, keys[loops].key_str) &&
loops >= NCANDIDATES - NKEY_PER_WINNER_LIST) {
printf("fail to set key %s\n", keys[loops].key_str);
nfailed++;
}
}
// at this moment, winner list's threshold is updated and it should
// forbiddn lower ref-count keys to be winner
loops = 2;
while (loops--) {
hot_key_update(rpt, small_key.key_str, KEY_LEN+1,
small_key.syndrome, small_key.bucket,
1+random()%11, ip);
}
recv[0] = '\0';
printf("keys:\n");
hot_key_report(rpt, top, recv, 300*top, 1, 0);
if (strstr(recv, small_key.key_str)) {
printf("small key should not be hot keys %s\n",
small_key.key_str);
nfailed++;
}
// continue with this key, it should be winner if
// ref-count is larger than threshold
hot_key_update(rpt, small_key.key_str, KEY_LEN + 1,
small_key.syndrome, small_key.bucket,
1 + random()%11, ip);
recv[0] = '\0';
printf("keys after small key increased:\n");
hot_key_report(rpt, top, recv, 300*top, 1, 0);
if (!strstr(recv, small_key.key_str)) {
printf("small key should be hot keys as it's no longer small %s\n",
small_key.key_str);
nfailed++;
}
// small_key = keys[NCANDIDATES - 1];
small_key.syndrome = keys[NCANDIDATES - NKEY_PER_WINNER_LIST].syndrome;
small_key.bucket = keys[NCANDIDATES - NKEY_PER_WINNER_LIST].bucket;
strcpy(small_key.key_str, keys[NCANDIDATES - NKEY_PER_WINNER_LIST].key_str);
if (strstr(recv, small_key.key_str)) {
printf("winner should be evicted out:%s\n",
small_key.key_str);
nfailed++;
}
recv[0] = '\0';
hot_client_report(rpt, top, recv, 300*top);
printf("clients:\n%s", recv);
hot_key_reset(rpt);
hot_key_cleanup(rpt);
plat_free(recv);
printf("failed = %d\n", nfailed);
done = 1;
}
