[일지] 1. TCP 소켓 맛보기 그리고 그리드 컴퓨팅

제가 이번 학교 주제탐구대회의 주제로 선정한 TCP/IP를 활용한 그리드 컴퓨팅에 대해 써봅니다.

우선 저의 소스코드는 엉망 진창임을 알려 드립니다.

주제탐구 최종보고서 제출마감일 세벽까지고쳐서 겨우 보고서는 작성 할 수 있는

수준일 뿐입니다.

저와 제 친구놈의 탐구는 다들 잘 아시는 IP와 TCP로 스마트폰을 서로 연결해서

친구놈의 노트북과 메르센 소수를 계산하는 속도를 겨루어서 그리드컴퓨팅의

능력을 확인하는 것이었습니다.

우선 이 실험은 거의 실패였습니다. 자세한 조사없이 쓸데없이 뭔가 있어보이는 메르센 소수를

실험대상으로 잡아버렸던 것이었습니다. 메르센소수는 p가 소수일때 2^p-1중 소수인 수입니다.

메르센수는 세계의 할일없고 초고성능의 컴퓨터를 가지고있는 수학자나 과학자들이 컴퓨터가

없던 시절부터 지금까지도 계속 찾고있음에도 49개밖에 찾지 못한 수였던 것이었습니다.

설계는 이렇습니다.

서버 - 계산해야할 수를 클라이언트에 알림

클라이언트 - 지정받은 수를 n이라고 할때

n이 소수인지 확인하고 소수이면 2^n-1

하고 그 수가 매르센느 수인지 확인후 

메르센느 수이면 서버에 전송

노병은 죽지않는다 다만, 사라질 뿐이다....

오른쪽 세개는 배터리 상태가 별로라서 수혈받으며 계산하고 있습니다.

결과가 처참합니다....

안드로이드에서는 clock함수가 윈도우와는다르게 10000단위로 올라가는 것 같습니다

이는 아마 윈도우의 10클락 정도로 추정하고 있습니다.

참고로 인텔 i5노트북은 M(19)까지 계산하는데 16클록 걸렸는데 

이놈은..... 10클록단위라 일단 53번 데이터까지 10000이니까 

16클록보다는 덜나오지 않았나 싶네요

실력이나 실험대상을 제쳐두고 이번 실험으로 느낀것은 

우선 TCP/IP는 타이밍을 중요시 해야해서 취미로 스파게티 코드를

양산하던 저에게는 엄청난 삽질이었고

그리드 컴퓨팅은 계산할 데이터의 분배가 문제였습니다

제 코드에 for문이 여러번 중첩되어있는데 이것이 나중에되면

수천번 수만번 혹은 그 이상으로 돌려야하는데 그런 데이터가

저 노병들에게 가서 혹사 시킨다면 아무리 많이 연결한들

노트북 하나를 이기는건 어림도 없을 것 같네요

참고로 저 사진들만으론 판단이 어렵겠지만 

5분간의 테스트 시간동안 M(31) = 2147483647을 

갤럭시gio (arm v6 800Mhz싱글코어)가 계산하는중 시간이 끝나버렸네요.

아래는 코드입니다 

보잘것없지만 심심하신분들은 코드에대한 조언 부탁드립니다.

서버와 리눅스는 안드로이드이므로 리눅스용 소켓 프로그램입니다.

윈도우에선 테스트 하실 수 없습니다

리눅스(우분투, 민트, 레드햇, 페도라)에서는 아마 될거에요

휴대폰에선 c4droid나 cppdroid로 테스트 해보실 수 있습니다.

서버

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/select.h>
#include <time.h>
#include <math.h>
 
typedef struct{
    double data, mrs_num;
    int num, pri;
} __receive;
 
typedef struct{
    double nn;
    int num;
} __send;
 
void error_handling(char * );
void start_socket (int * fd, const char port[]);
void user_help(void);
 
int main(int argc, char * argv[])
{
    int n=0;
    int serv_sock, clnt_sock;
    int str_len;
    struct sockaddr_in serv_addr, clnt_addr;
    struct timeval timeout;
    fd_set reads, cpy_reads;
 
    socklen_t clnt_addr_size;
    int fd_max, fd_num, i;
//    clnt_addr_size = sizeof(clnt_addr);
    char port[4];
    FILE* file;
    
    printf("PORT : ");
    scanf("%s", port);
    
    clock_t start = clock();
    
    __send send;
    send.nn=2.0;
    send.num=5;
 
    __receive receive;     //client calculate result
    
    //server start
    start_socket((int *)&serv_sock, port); 
    
    FD_ZERO(&reads);
    FD_SET(serv_sock, &reads);
    fd_max=serv_sock;
 
    
    file = fopen("result.txt", "w");
    fprintf(file, "result.txt\n==============\n");
 
 
    
    while(1)
    {
        cpy_reads=reads;
        timeout.tv_sec=5;    //5
        timeout.tv_usec=5000;    //5000
 
        fd_num=select(fd_max+1, &cpy_reads, 0, 0, 0);
        if(fd_num==0)
            continue;
 
        for(i=0; i<fd_max+1; i++)
        {
            if(FD_ISSET(i, &cpy_reads))
            {
                if(i==serv_sock)    //connection request!
                {
                    clnt_addr_size=sizeof(clnt_addr);
                    //client connect
                    clnt_sock = accept(serv_sock, (struct sockaddr*) &clnt_addr, &clnt_addr_size);
                    FD_SET(clnt_sock, &reads);
                    if(clnt_sock==-1)
                    {
                        perror("accept");
                        error_handling("accept() error");
                    }
 
                    if(fd_max<clnt_sock)
                        fd_max=clnt_sock;
                    printf("connected client : %d \n", clnt_sock);
                    write(clnt_sock, &send, sizeof(send));
                    send.nn += (int)send.num;
                }
                else    //read message!
                {
                    str_len = read(i, &receive, sizeof(receive));
                    if(str_len <= 0)
                    {
                        FD_CLR(i, &reads);
                        close(i);
                        printf("connection lost\n");
                        goto fin;
                    }
                    if(fabs(receive.data) < 0.000001)
                    {
                        
                        write(i, &send, sizeof(send));
                        send.nn += (int)send.num;
                    }
        
                    //receive data form client fin.
                    else
                    {
                        n++;
                        fprintf(file, "%d : max mrs prime : M(%.0f) %.0f\n\n",n, receive.mrs_num, receive.data);
                        printf("%d : M(%.0f) %.0f\n",n, receive.mrs_num, receive.data);
                    }
        
                }
            }
        }
    }
 
    
    
 
        
    fin:
    close(clnt_sock);
    close(serv_sock);
    fprintf(file, "==============\n");
    printf("result.txt saved!!\n");
    fclose(file);
    
    return 0;
}
 
void error_handling(char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    //exit (1);
}
 
void start_socket (int * fd, const char port[])
{
    struct sockaddr_in serv_addr;
    *fd = socket(PF_INET, SOCK_STREAM, 0);
    if(*fd == -1)
        error_handling("socket() error");
        
    memset(&serv_addr, 0, sizeof(serv_addr));
    serv_addr.sin_family = AF_INET;
    serv_addr.sin_port = htons(atoi(port));
    serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);
        
    if(bind(*fd, (struct sockaddr *)&serv_addr, sizeof(serv_addr)) == -1)
        error_handling("bind() error");
    
    if(listen(*fd, 20) == -1)
        error_handling("listen() error");
        
    return;
}
 

클라이언트 

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
    
 
int mod_double(double a, double b);
 
    
int main(int argc, char* argv[])
{
    int pri, num;
    double nn, bre, i, mrs, mrs_num;
    int mrsp = 0;
    time_t start = clock();
 
 
//mrs_prime.c
 
    start = clock();
 
 
    while (1)
    {
        
        for(nn; nn<bre; nn++)
        {
        
            pri = 1;
 
            for(i=2.0; i<nn; i+=1.0)
            {
                if(mod_double(nn, i)==0)
                {
                    pri = 0;
                    printf("This num is not prime / time : %.2f sec\n", (double)(clock()-start)/1000000);
                    break;
                }
                    
            }
 
            if(pri==1)
            {
                send.pri += 1;
                mrs = pow(2.0, nn)-1;
                for(i=2.0; i<mrs; i++)
                {
                    if(mod_double(mrs, i)==0)
                    {
                        pri=0;
                        printf("This num is not mrs prime / time : %.2f sec\n", (double)(clock()-start)/1000000);    
                        break;
                    }
                    if(clock()-start>5*60*1000000)
                        goto fin;
                }
            
                if(pri ==1) 
                {
                    mrsp += 1; send.mrs_num = nn;
                    send.data=mrs;        //data in
                    write(sock, &send, sizeof(send));
                    printf("%d : mrs prime is : %.0f / time : %.2f sec\n\n\n",mrsp, mrs, (double)(clock()-start)/1000000);
 
                    
                }
            }
        
        }
            
        send.mrs_num=0;
        send.data=0;
        send.num=0;
        retry(sock, &send, sizeof(send));
    }
    fin:
    printf("time out!\n");
    close(sock);
    return 0;
}
 
 
    
void error_handling (char *message)
{
    fputs(message, stderr);
    fputc('\n', stderr);
    exit(1);
}
 
int mod_double(double a, double b)
{
    return a - b*((int)a/(int)b);
}
 
void retry(int sock, void * send, int size)
{
    while(1)
    {
        if(write(sock, &send, sizeof(send))<=0)
        {
            printf("waiting server\n\n\n");
            usleep(100000);
        }
        else
            break;
    }
    return;
}
 
/*
void interrupt(void)
{
    sendd.mrs_num = nn;
    sendd.data=mrs;        //data in
    sendd.num=mrsp;        //data num
    write(sock, &sendd, sizeof(sendd));
    printf("%d : mrs prime is : %.0f / time : %.2f sec\n\n\n",mrsp, mrs, (double)(clock()-start)/1000000);
    close(sock);
}

void CTL_handler(int signo)
{
    interr