2 #include <netinet/tcp.h>
5 inline int test_and_set(volatile unsigned int *addr) {
7 /* Note: the "xchg" instruction does not need a "lock" prefix */
8 __asm__ __volatile__("xchgl %0, %1"
9 : "=r"(oldval), "=m"(*(addr))
10 : "0"(1), "m"(*(addr)));
13 inline void UnLock(volatile unsigned int *addr) {
15 /* Note: the "xchg" instruction does not need a "lock" prefix */
16 __asm__ __volatile__("xchgl %0, %1"
17 : "=r"(oldval), "=m"(*(addr))
18 : "0"(0), "m"(*(addr)));
21 # error need implementation of test_and_set
26 inline void Lock(volatile unsigned int *s) {
27 while(test_and_set(s)) {
38 sockPoolHashTable_t *createSockPool(sockPoolHashTable_t * sockhash, unsigned int size) {
39 if((sockhash = calloc(1, sizeof(sockPoolHashTable_t))) == NULL) {
40 printf("Calloc error at %s line %d\n", __FILE__, __LINE__);
44 socknode_t **nodelist;
45 if ((nodelist = calloc(size, sizeof(socknode_t *))) < 0) {
46 printf("Calloc error at %s line %d\n", __FILE__, __LINE__);
51 sockhash->table = nodelist;
52 sockhash->inuse = NULL;
53 sockhash->size = size;
59 int createNewSocket(unsigned int mid) {
62 if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
63 printf("%s() Error: In creating socket at %s, %d\n", __func__, __FILE__, __LINE__);
66 setsockopt(sd, IPPROTO_TCP, TCP_NODELAY, (char *) &flag, sizeof(flag));
67 struct sockaddr_in remoteAddr;
68 bzero(&remoteAddr, sizeof(remoteAddr));
69 remoteAddr.sin_family = AF_INET;
70 remoteAddr.sin_port = htons(LISTEN_PORT);
71 remoteAddr.sin_addr.s_addr = htonl(mid);
72 if(connect(sd, (struct sockaddr *)&remoteAddr, sizeof(remoteAddr)) < 0) {
73 perror("socket connect: ");
74 printf("%s(): Error %d connecting to %s:%d\n", __func__, errno, inet_ntoa(remoteAddr.sin_addr), LISTEN_PORT);
81 int getSockWithLock(sockPoolHashTable_t *sockhash, unsigned int mid) {
83 int key = mid%(sockhash->size);
86 Lock(&sockhash->mylock);
87 ptr=&(sockhash->table[key]);
90 if (mid == (*ptr)->mid) {
94 tmp->next=sockhash->inuse;
96 UnLock(&sockhash->mylock);
101 UnLock(&sockhash->mylock);
102 if((sd = createNewSocket(mid)) != -1) {
103 socknode_t *inusenode = calloc(1, sizeof(socknode_t));
105 inusenode->mid = mid;
106 insToListWithLock(sockhash, inusenode);
113 int getSock(sockPoolHashTable_t *sockhash, unsigned int mid) {
115 int key = mid%(sockhash->size);
118 ptr=&(sockhash->table[key]);
121 if (mid == (*ptr)->mid) {
122 socknode_t *tmp=*ptr;
125 tmp->next=sockhash->inuse;
131 if((sd = createNewSocket(mid)) != -1) {
132 socknode_t *inusenode = calloc(1, sizeof(socknode_t));
133 inusenode->next=sockhash->inuse;
134 sockhash->inuse=inusenode;
141 int getSock2(sockPoolHashTable_t *sockhash, unsigned int mid) {
143 int key = mid%(sockhash->size);
146 ptr=&(sockhash->table[key]);
149 if (mid == (*ptr)->mid) {
154 if((sd = createNewSocket(mid)) != -1) {
155 *ptr=calloc(1, sizeof(socknode_t));
164 /*socket pool with multiple TR threads asking to connect to same machine */
165 int getSock2WithLock(sockPoolHashTable_t *sockhash, unsigned int mid) {
167 int key = mid%(sockhash->size);
170 Lock(&sockhash->mylock);
171 ptr=&(sockhash->table[key]);
173 if (mid == (*ptr)->mid) {
174 UnLock(&sockhash->mylock);
179 UnLock(&sockhash->mylock);
180 if((sd = createNewSocket(mid)) != -1) {
181 socknode_t *inusenode = calloc(1, sizeof(socknode_t));
183 inusenode->mid = mid;
184 addSockWithLock(sockhash, inusenode);
191 void addSockWithLock(sockPoolHashTable_t *sockhash, socknode_t *ptr) {
192 int key = ptr->mid%(sockhash->size);
193 Lock(&sockhash->mylock);
194 ptr->next = sockhash->table[key];
195 sockhash->table[key] = ptr;
196 UnLock(&sockhash->mylock);
199 void insToListWithLock(sockPoolHashTable_t *sockhash, socknode_t *inusenode) {
200 Lock(&sockhash->mylock);
201 inusenode->next = sockhash->inuse;
202 sockhash->inuse = inusenode;
203 UnLock(&sockhash->mylock);
206 void freeSock(sockPoolHashTable_t *sockhash, unsigned int mid, int sd) {
207 int key = mid%(sockhash->size);
208 socknode_t *ptr = sockhash->inuse;
209 sockhash->inuse = ptr->next;
212 ptr->next = sockhash->table[key];
213 sockhash->table[key] = ptr;
216 void freeSockWithLock(sockPoolHashTable_t *sockhash, unsigned int mid, int sd) {
217 int key = mid%(sockhash->size);
219 Lock(&sockhash->mylock);
220 ptr = sockhash->inuse;
221 sockhash->inuse = ptr->next;
224 ptr->next = sockhash->table[key];
225 sockhash->table[key] = ptr;
226 UnLock(&sockhash->mylock);
230 / ***************************************/
231 * Array Implementation for socket resuse
232 * ***************************************/
236 sock_pool_t *initSockPool(unsigned int *mid, int machines) {
237 sock_pool_t *sockpool;
238 num_machines = machines;
239 if ((sockpool = calloc(num_machines, sizeof(sock_pool_t))) < 0) {
240 printf("%s(), Calloc error at %s, line %d\n", __func__, __FILE__, __LINE__);
244 for (i = 0; i < num_machines; i++) {
245 if ((sockpool[i].sd = calloc(MAX_CONN_PER_MACHINE, sizeof(int))) < 0) {
246 printf("%s(), Calloc error at %s, line %d\n", __func__, __FILE__, __LINE__);
249 if ((sockpool[i].inuse = calloc(MAX_CONN_PER_MACHINE, sizeof(char))) < 0) {
250 printf("%s(), Calloc error at %s, line %d\n", __func__, __FILE__, __LINE__);
253 sockpool[i].mid = mid[i];
255 for(j = 0; j < MAX_CONN_PER_MACHINE; j++) {
256 sockpool[i].sd[j] = -1;
263 int getSock(sock_pool_t *sockpool, unsigned int mid) {
265 for (i = 0; i < num_machines; i++) {
266 if (sockpool[i].mid == mid) {
268 for (j = 0; j < MAX_CONN_PER_MACHINE; j++) {
269 if (sockpool[i].sd[j] != -1 && (sockpool[i].inuse[j] == 0)) {
270 sockpool[i].inuse[j] = 1;
271 return sockpool[i].sd[j];
273 if (sockpool[i].sd[j] == -1) {
276 if((sd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
277 printf("%s() Error: In creating socket at %s, %d\n", __func__, __FILE__, __LINE__);
280 struct sockaddr_in remoteAddr;
281 bzero(&remoteAddr, sizeof(remoteAddr));
282 remoteAddr.sin_family = AF_INET;
283 remoteAddr.sin_port = htons(LISTEN_PORT);
284 remoteAddr.sin_addr.s_addr = htonl(mid);
286 if(connect(sd, (struct sockaddr *)&remoteAddr, sizeof(remoteAddr)) < 0) {
287 printf("%s(): Error %d connecting to %s:%d\n", __func__, errno, inet_ntoa(remoteAddr.sin_addr), LISTEN_PORT);
291 sockpool[i].sd[j] = sd;
292 sockpool[i].inuse[j] = 1;
293 return sockpool[i].sd[j];
296 printf("%s()->Error: Less number of MAX_CONN_PER_MACHINE\n", __func__);
300 printf("%s()-> Error: Machine id not found\n", __func__);
305 int freeSock(sock_pool_t *sockpool, int sd) {
307 for (i = 0; i < num_machines; i++) {
309 for (j = 0; j < MAX_CONN_PER_MACHINE; j++) {
310 if (sockpool[i].sd[j] == sd) {
311 sockpool[i].inuse[j] = 0;
316 printf("%s() Error: Illegal socket descriptor %d\n", __func__, sd);