void tst_expr_substitution() {
memory::initialize(0);
ast_manager m;
reg_decl_plugins(m);
bv_util bv(m);
expr_ref a(m), b(m), c(m), d(m);
expr_ref x(m);
expr_ref new_a(m);
proof_ref pr(m);
x = m.mk_const(symbol("x"), bv.mk_sort(8));
a = mk_bv_and(bv, mk_bv_xor(bv, x,bv.mk_numeral(8,8)), mk_bv_xor(bv,x,x));
b = x;
c = bv.mk_bv_sub(x, bv.mk_numeral(4, 8));
expr_substitution subst(m);
th_rewriter rw(m);
std::cout << mk_pp(c, m) << "\n";
// normalizing c does not help.
rw(c, d, pr);
std::cout << mk_pp(d, m) << "\n";
// This portion diverges. It attempts to replace x by (bvadd #xfc x), which contains x.
// subst.insert(b, d);
// std::cout << mk_pp(a, m) << "\n";
// rw.set_substitution(&subst);
// enable_trace("th_rewriter_step");
// rw(a, new_a, pr);
// std::cout << mk_pp(new_a, m) << "\n";
}
int PronyADMMClient(char* server_host, char* server_port, char* data_port,
char* strategy, char* backupserver1_host, char* backupserver2_host,
char* backupserver3_host, char* backupserver4_host,
char* backupserver_port, char* num_of_attack, char* num_of_pdcs) {
FILE* fFile;
Logger* fLogger;
fFile = fopen("/tmp/PronyADMM_client.log", "a");
fLogger = Logger_create(fFile, 0);
log_debug(fLogger,"Start Prony client");
//For collecting event log and result
int argc = 15;
ofstream myfile;
char filename[50];
char tempbuf1[5];
char tempbuf2[5];
char tempbuf3[5];
char timebuffer[25];
time_t now_time;
time(&now_time);
struct tm * tm_info;
tm_info = localtime(&now_time);
strcpy(filename, "/tmp/DistriProny_Result_");
strcat(filename, data_port);
strcat(filename, "_");
snprintf(tempbuf1, 5, "%d", tm_info->tm_year+1900);
strcat(filename, tempbuf1);
strcat(filename, "-");
//itoa(now->tm_mon + 1, tempbuf2, 10);
snprintf(tempbuf2, 5, "%d", tm_info->tm_mon + 1);
strcat(filename, tempbuf2);
strcat(filename, "-");
//itoa(now->tm_mday, tempbuf3, 10);
snprintf(tempbuf3, 5, "%d", tm_info->tm_mday);
strcat(filename, tempbuf3);
strcat(filename, ".txt");
myfile.open(filename);
int Iteration = 0; // Iteration = packet_no
int counter = 0;
int num_attack = 0;
int i = 0;
int Algorithm_Finishes = 0;
struct timeval tvalStart, Start, End, Result, algo_start_time, timeout;
gettimeofday (&Start, NULL);
// Read sock for connection monitor of resiliency mechanism
fd_set readfds;
int select_ret;
// Declare a vector for store the sample data
vector<double> theta;
theta.clear();
//===============1. Setup a TCP connection of client for sending localpara to main Prony_server============//
struct hostent *he;
struct in_addr **addr_list;
char* ip;
if ((he = gethostbyname(server_host)) == NULL) { // get the host info
exit(1);
}
// print information about this host:
addr_list = (struct in_addr **)he->h_addr_list;
for(i = 0; addr_list[i] != NULL; i++) {
ip = inet_ntoa(*addr_list[i]);
}
int sockfd = 0;
struct sockaddr_in serv_addr;
memset(&serv_addr, '0', sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
serv_addr.sin_port = htons(atoi(server_port));
if(inet_pton(AF_INET, ip, &serv_addr.sin_addr)<=0) {
log_error(fLogger,"inet pton error");
return 1;
}
log_debug(fLogger, "Server Host: %s, IP: %s, Port:%s", server_host, ip, server_port);
// Create a socket and connection with old server
if((sockfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
log_error(fLogger,"Could not create socket.");
return 1;
}
log_debug(fLogger,"Socket created");
if(connect(sockfd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1) {
log_error(fLogger,"connect() failed.");
return 1;
}
log_debug(fLogger,"TCP Connection has been set up");
//===============2. Setup a TCP connection of server for receiving sample data from PMU============//
// Set up TCP socket of server side for collecting PMU measurements for single PMU machine
int Server_sockfd, data_sockfd;
struct sockaddr_in LocalAddr, PMU_address;
int Client_len = sizeof(PMU_address);
// Initiate local TCP server socket
LocalAddr.sin_family = AF_INET;
LocalAddr.sin_addr.s_addr = htonl(INADDR_ANY);
LocalAddr.sin_port = htons(atoi(data_port));
// Create, bind and listen the TCP_socket
Server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (bind(Server_sockfd, (struct sockaddr *)&LocalAddr, sizeof(LocalAddr)) < 0) {
log_debug(fLogger,"bind issue");
cout<<"Error: Can not bind the TCP socket! \n Please wait a few seconds or change port number."<<endl;
return 1;
}
listen(Server_sockfd, DEFAULT_QUEUE_LEN);
data_sockfd = accept(Server_sockfd,(struct sockaddr *)&PMU_address, (socklen_t*)&Client_len);
printf("PMU Connection has been accepted and Prony VM is waiting for data ...\n");
//===============3. Parameters for Receiving PMU data and Parse data ====================//
// Declare char pointer to token when parsing data
char *token;
string last;
char b, lastchar;
last = &b;
int length, last_flag;
int j, k;
char Buffer[DEFAULT_MAX_BUFFER_LEN] = {0};
char tempBuffer[DEFAULT_MAX_BUFFER_LEN];
unsigned data_length;
long int packet_send_time;
// Prepare packet receiver buffer
char *receive_packet;
if((receive_packet=(char *)malloc(SERVER_MAX_BUF+sizeof(struct TCP_header)))==NULL) {
cout<<"Fail to allocate memory for receive buffer, program is exiting ... "<<endl;
exit(1);
}
struct TCP_header *receive_packet_header=(struct TCP_header *)receive_packet;
char *receive_packet_content=(char *)(receive_packet_header+1);
//================4. Calculate initial parameter vector a ================================//
// Construct Intermedia Matrix H, C, a
mat I(ParaNum, ParaNum);
mat a(ParaNum,1);
mat new_a(ParaNum,1);
mat avgpara(ParaNum,1);
mat new_avgpara(ParaNum,1);
mat w(ParaNum,1);
mat new_w(ParaNum,1);
mat H(IniHeight,ParaNum);
mat C(IniHeight,1);
int TT;
for (i=0; i<ParaNum; i++) {
for (j=0; j<ParaNum; j++) {
if (i==j){
I(i,j) = 1;
} else {
I(i,j) = 0;
}
}
}
for (i=0; i<ParaNum; i++) {
a(i,0) = 1;
w(i,0) = 0;
avgpara(i,0) = 1;
}
//===============5. Parameters for Exchange Estimated Parameters with Server=====================//
// form localpara message
char* buffer = (char*)malloc(512*sizeof(char));
int size, avgBufferLen, flag;
// Prepare receive buffer for avgpara
char *avgBuffer = (char*)malloc(512*sizeof(char));
// For calculate new local parameters
char *pht;
// ======================= Main loop: Receive PMU data and Parse data and PronyADMM =========================//
while(1) {
log_debug(fLogger,"Main loop begin. Iteration: %d", Iteration);
read(data_sockfd, receive_packet, DEFAULT_MAX_BUFFER_LEN);
data_length = receive_packet_header->data_length;
last_flag = receive_packet_header->last_flag;
packet_send_time = receive_packet_header->packet_sending_time;
// If this is not last package, request next one
if (last_flag == 0) {
size=sprintf(tempBuffer, "Request Next Package %d! \r\n\r\n",(Iteration+1));
printf( "Prony client VM Writes:\n %s \n", tempBuffer);
write(data_sockfd, tempBuffer, size);
// end request next one
}
memset(Buffer, '\0', 15);
//log_debug(fLogger, "The length of last string is %d", last.length());
if((last.length()!= 0) && (Iteration != 0)) strncat(Buffer, last.c_str(), last.length()+1);
strncat(Buffer, receive_packet_content, data_length);
lastchar = Buffer[last.length()*sizeof(char)+data_length-1];
//log_debug(fLogger, "After receive packet %d, Buffer contains \n %s \n", Iteration, Buffer);
memset(Buffer+(last.length()+data_length+1)*sizeof(char), '\0', 20);
// ================= Parse the data from the Buffer ================= //
length = 0;
while (1) {
token = strtok(Buffer+length*sizeof(char), "\n");
if (token == NULL){
if(last_flag == 0) theta.pop_back(); //if this is not last packet, the last record is discarded.
break;
}
last = token;
//log_debug(fLogger, "The data is %s", token);
theta.push_back(strtod(token, NULL));
length = length + strlen(token) + 1;
} // end of parsing data
if (lastchar == '\n')
last.append("\n");
for (i=0; i<(int)theta.size(); i++)
//cout<<"theta["<<i<<"] is "<<theta[i]<<endl;
// (II): Process each sample in this packet
if (theta.size() >= IniHeight+ParaNum) {
log_debug(fLogger, "size of theta is %d", theta.size());
for (k=counter; k<(int)theta.size(); k++) {
log_debug(fLogger, "Iteration: %d", k);
gettimeofday(&algo_start_time, NULL);
// Step 1: Update matrice H and C, and Calculate new_a
if (IniHeight+floor(k/5)<Height_H){
TT = IniHeight + floor(k/5);
} else {
TT = Height_H;
}
H.set_size(TT,ParaNum);
C.set_size(TT,1);
for (i=0; i<TT; i++){
C(i,0) = theta[ParaNum+i];
} //Note: we donot update C matrix real-time
//C.print("C is");
for (i=0; i<TT; i++){
for (j=0; j<ParaNum; j++){
H(i,j) = theta[i+ParaNum-1-j];
}
}
new_a = inv(trans(H)*H + rho*I)*(trans(H) * C - w + rho*avgpara);
// Step 2: Send out local parameter vector new_a
gettimeofday (&tvalStart, NULL); // Record sending time
// Format the export message
size = sprintf(buffer, "Iteration: %d, %s: %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f\r\n Starttime: %ld \r\n\r\n",
k, data_port, new_a(0), new_a(1), new_a(2), new_a(3), new_a(4), new_a(5), new_a(6), new_a(7), new_a(8),
new_a(9), new_a(10), new_a(11), new_a(12), new_a(13), new_a(14), new_a(15), new_a(16), new_a(17), new_a(18),
new_a(19), (tvalStart.tv_sec*1000000 + tvalStart.tv_usec));
//log_debug(fLogger, "The value of size is %d", size);
log_debug(fLogger, "Sending message with time %ld", (tvalStart.tv_sec*1000000 + tvalStart.tv_usec));
// =========================== Resiliency Mechanism ===========================//
//log_debug(fLogger, "Writing to server");
flag = write(sockfd, buffer, size);
if (flag <= 0) {
log_debug(fLogger, "Main server got attacked because the return value of write() function is negative.");
num_attack++;
sockfd = attackResProtocol(backupserver1_host,
backupserver2_host,
backupserver3_host,
backupserver4_host,
backupserver_port, num_of_attack,
num_of_pdcs, num_attack,
sockfd, fLogger);
write(sockfd, buffer, size); // Write the local estimation to new server
}
//log_debug(fLogger, "Write successful");
if (Iteration == 1) {
timeout.tv_sec = TEMP_TIMEOUT_SEC;
timeout.tv_usec = TEMP_TIMEOUT_USEC;
} else {
timeout.tv_sec = TIMEOUT_SEC;
timeout.tv_usec = TIMEOUT_USEC;
}
// initializes the set of active read sockets
FD_ZERO(&readfds);
FD_SET(sockfd, &readfds);
log_debug(fLogger, "Selecting sockets to read");
select_ret = select(sockfd+1, &readfds, NULL, NULL, &timeout);
log_debug(fLogger,"Return value of select is %d", select_ret);
if(select_ret <= 0) { //case: error or timeout of select_ret is 0
num_attack++;
log_debug(fLogger,"Main Server's link got attacked because the read() function times out.");
sockfd = attackResProtocol(backupserver1_host,
backupserver2_host,
backupserver3_host,
backupserver4_host,
backupserver_port, num_of_attack,
num_of_pdcs, num_attack,
sockfd, fLogger);
write(sockfd, buffer, size); // Write the local estimation to new server
}// end if
//log_debug(fLogger, "Select successful");
// ========================== End of Resiliency Mechanisim ==========================//
//log_debug(fLogger, "Reading from server");
avgBufferLen = read(sockfd, avgBuffer, DEFAULT_MAX_BUFFER_LEN);
log_debug(fLogger,"Return value of read is %d", avgBufferLen);
if (avgBufferLen <= 0) {
num_attack++;
log_info(fLogger,"Main server got attacked because the return value of read() function is negative. Error: %d", errno);
sockfd = attackResProtocol(backupserver1_host,
backupserver2_host,
backupserver3_host,
backupserver4_host,
backupserver_port, num_of_attack,
num_of_pdcs, num_attack,
sockfd, fLogger);
write(sockfd, buffer, size); // Write the local estimation to new server
avgBufferLen = read(sockfd, avgBuffer, DEFAULT_MAX_BUFFER_LEN);
}
//log_debug(fLogger, "Read successful");
avgBuffer[avgBufferLen]=0;
if (strcmp(avgBuffer,"Distributed Prony Alogrithm finishes! \r\n\r\n")==0) {
Algorithm_Finishes = 1;
log_info(fLogger,"Distributed Prony Alogrithm finishes!");
break;
}
//Parse new_avgpara
pht = strtok(avgBuffer, " ");
pht = strtok(NULL, " ");
pht = strtok(NULL, " ");
//printf("This should be %s\n", pht);
for (j=0; j<ParaNum; j++){
pht = strtok(NULL, " ");
new_avgpara(j,0) = strtod(pht, NULL);
}
// Step 4: Update newer matrix C, H, and local para, Iteration ====================/
new_w = w + rho*(new_a - new_avgpara);
a = new_a;
avgpara = new_avgpara;
w = new_w;
}//end of for loop
break;
}//end of if sentence with theta.size()>initialHeight
log_debug(fLogger,"End of Main loop. Iteration: %d", Iteration);
if (Algorithm_Finishes == 1)
break;
counter = theta.size();
Iteration++;
} //end big while loop
if (Algorithm_Finishes == 1) {
size = sprintf(tempBuffer, "Distributed Prony Alogrithm finishes! \r\n\r\n");
printf( "Prony Client VM Writes to PMU machine:\n %s \n", tempBuffer);
write(data_sockfd, tempBuffer, size);
}
close(sockfd);
log_debug(fLogger,"Prony algorithm ends happily. ^_^");
gettimeofday (&End, NULL);
timer_sub(&Start, &End, &Result);
fclose(fFile);
return 0;
} /* end of PronyADMMClient */
