main.cpp

systemc源码

/************************************************************************
 * file name:	main.cpp
 * description:	SystemC module with TCP clientt and server,
 *			compiled in linux.
 *
 * modification history
 * --------------------
 * 04.4.7, created by zhuwei
 */

/* includes----------------------------------------------------------- */
#include "systemc.h"

#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <sys/select.h>
#include <arpa/inet.h>

//#include <fcntl.h>

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <pthread.h>

#include <deque> // STL

/* defines------------------------------------------------------------ */
#define TCP_PORT 1045
#define BUF_SIZE 128
#define MAX_PENDING 5

/* typedefs----------------------------------------------------------- */

bool client_connect();
void client_send(void *data, int size);
deque<int >	buf(BUF_SIZE, 0);

struct module_a: sc_module
{
	sc_in<bool>			clk;
	int 				i, j;
	bool				connected;

	void reg_fun()
	{
		if(!connected)
		{
			connected = client_connect();
		}
		else
		{
			i++;
			if(i % 1000000 == 0)
			{
				j++;

				client_send((void *)&j, sizeof(int));
				cout << name() << " send data: " << j << endl;
			}
		}
	}

	SC_CTOR(module_a): j(245), connected(false)
	{
		//client_connect();

		SC_METHOD(reg_fun);
		sensitive_pos << clk;
	}
};

struct module_b: sc_module
{
	sc_in<bool>			clk;
	int				data;

	void reg_fun()
	{
		if(!buf.empty())
		{
			data = *buf.begin();
			buf.pop_front();

			cout << name() << " recv data: " << data << endl;
		}
	}

	SC_CTOR(module_b)
	{
		SC_METHOD(reg_fun);
		sensitive_pos << clk;
	}
};

/* externs------------------------------------------------------------ */
/* globals------------------------------------------------------------ */
char				*dest_ip = "12.2.4.72";
int				svr_sock, clt_sock;
struct 	sockaddr_in		dest_addr;

/* forward declarations----------------------------------------------- */

void run_svr(void * p)
{

	struct sockaddr_in	local_addr;
	//-----------------------------------
	fd_set 			read_set;
	int			in_sock;

	memset(&local_addr, 0 , sizeof(struct sockaddr));
	local_addr.sin_family = AF_INET;
	local_addr.sin_port = htons(TCP_PORT);
	local_addr.sin_addr.s_addr = INADDR_ANY;
	if(bind(svr_sock, (struct sockaddr *)&local_addr, sizeof(struct sockaddr))!=0) 
	{
		fprintf(stderr, "error bind\n");
		return;
	}

	if(listen(svr_sock, MAX_PENDING) != 0)
	{
		fprintf(stderr, "error listen\n");
		return;
	}

	while(1)
	{
	
		printf("wait to accept...\n");


		socklen_t addr_size = sizeof(struct sockaddr);
		in_sock = accept(svr_sock, (struct sockaddr *)&local_addr, &addr_size);
		if(in_sock == -1)
		{
			fprintf(stderr, "accept error\n");
			return;
		}
		else printf("accept ok\n");

		

		printf("wait to receive...\n");

		FD_ZERO (&read_set);
		FD_SET(in_sock, &read_set);

		if(select(in_sock+1, &read_set, NULL, NULL, NULL) < 0)
		{
			fprintf(stderr, "select error\n");
			continue;
		}

		if (FD_ISSET (in_sock, &read_set))
		{
			unsigned char	buffer[1024];
			int		recv_size;
			int		data;

			socklen_t addr_size = sizeof(struct sockaddr);

			while((recv_size = recvfrom(in_sock, buffer, 1024, 0, (struct sockaddr *)&local_addr, &addr_size)) > 0)
			{
				memcpy(&data, buffer, sizeof(int));
				printf("----%d\n", data);
				buf.push_back(data);
			}

			close(in_sock);
		}

	}

}

void client_send(void *data, int size)
{
	int			ret;

	ret = sendto(clt_sock, data, size, 0, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr));
	if(ret<0)fprintf(stderr, "error sending.\n");

}

bool client_connect()
{
	memset(&dest_addr, 0 , sizeof(struct sockaddr));
	dest_addr.sin_family = AF_INET;
	dest_addr.sin_port = htons(TCP_PORT);
	dest_addr.sin_addr.s_addr =  inet_addr(dest_ip);

	if(connect(clt_sock, (struct sockaddr *)&dest_addr, sizeof(struct sockaddr)) != 0)
	{
		//fprintf(stderr, "connect error\n");
		return false;
	}
	else 
	{
		fprintf(stderr, "connect ok\n");
		return true;
	}
}

int sc_main(int argc, char *argv[])
{
	sc_clock		clk("clk", 1000, SC_NS);
	//sc_signal<int>	data;
	//-----------------------------
	pthread_t 		svr_thrd;
	int 			ret;
	
	buf.clear();
	
	svr_sock = socket( AF_INET, SOCK_STREAM, 0 );
	if(svr_sock < 0) fprintf(stderr, "error create server socket\n");
	
	clt_sock = socket( AF_INET, SOCK_STREAM, 0 );
	if(clt_sock < 0) fprintf(stderr, "error create client socket\n");
	
	setsockopt(svr_sock, SOL_SOCKET, SO_REUSEADDR, &ret, sizeof(ret));
	//fcntl(svr_sock, F_SETFL, O_NONBLOCK);
	setsockopt(clt_sock, SOL_SOCKET, SO_REUSEADDR, &ret, sizeof(ret));
	//fcntl(clt_sock, F_SETFL, O_NONBLOCK);

	
	module_a	ma("ma");
	ma(clk);
	
	module_b	mb("mb");
	mb(clk);

	ret = pthread_create(&svr_thrd, NULL, (void *(*) (void *))run_svr, /*(void *)&data*/ NULL);
	if(ret)
	{
		perror("pthread_create: run_svr");
		exit(EXIT_FAILURE);
	}

	sc_start(-1);

	close(svr_sock);
	close(clt_sock);
	
	return 0;
}