매일 공부 일기

(2022-12-01 ~ 2022-12-02) 시험을 앞둔 대학생

HJ39 2022. 12. 2. 21:39

멀고도 험했던 2학기 종강이 드디어 얼마 남지 않았다. (11일 뒤면 끝이다!!)

그치만 11일안에 모든 시험과 팀프로젝트를 마무리를 해야해서 시간이 너무 부족하다 ㅠ

 

 

# 유닉스 시스템 프로그래밍 팀프로젝트 

유닉스 팀프로젝트 세그먼트 오류 즉 메모리 침범 오류 때문에 처음부터 코드를 천천히 검사하면서 새로 작성했다..

천천히 작성하고 파이프 통신을 하기 위해 쓰레드 하나하나 신경쓰면서 작성했더니 오류가 발생하지 않는다!!(이때 솔직히 환호성 지름)

 

팀프로젝트 pipe코드

#include <sys/time.h>
#include <sys/wait.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <pthread.h>
#include <stdbool.h>
#include <time.h>

#define MAXSIZE 6
char *msg1 = "my";
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
int point = 0;
bool checkPoint = true;
void* checkingChild0Msg(int pip[2]);
void* checkingChild1Msg(int pip[2]);
void* sendMsgCtoP(int pip[2]);
int child(int pip[2],int resultp[2]);
void* recvMsgPtoC(int resP[2]);
void* sendMsgCtoP1(int pip[2]);
int child1(int pip[2],int resultp[2]);
void* recvMsgPtoC1(int resP[2]);
int parent(int pip[2][2],int resultp[2][2]);
pid_t child0Pid;
pid_t child1Pid;
struct timespec begin, middle, end;


int main(){
        int i;
        int pip[2][2];
        int resultp[2][2];

        for(i =0; i<2; i++){
                if(pipe(pip[i]) == -1){
                        printf("pipe error\n");
                        exit(0);
                }
                if(pipe(resultp[i]) == -1){
                        printf("result pipe error \n");
                        exit(0);
 }
                printf("pipe create%d\n",i);

        }
        switch(child0Pid = fork()){
                case -1:
                        printf("fork error!\n");
                        exit(0);
                case 0:{
                               switch(child1Pid = fork()){
                                       case -1:
                                               printf("fork error2!\n");
                                               exit(0);
                                       case 0:{
                                                      child(pip[0],resultp[0]);
                                                      break;
                                              }
                                       default:{
                                                       child1(pip[1],resultp[1]);
                                                       break;
                                               }
                               }

                               break;
                       }
                default:{
                                parent(pip,resultp);
                        }
        }

}

void* checkingChild0Msg(int pip[2]){
        int count =0;
        char buf[MAXSIZE];
        for(;;){
                pthread_mutex_lock(&lock);
                if(checkPoint && (point < 3 && point > -3)){
                        if(read(pip[0],buf,MAXSIZE)>0){
                                point++;
                                printf("Child0 point = %d\n",point);
								}
								pthread_mutex_unlock(&lock);
                        sleep(0.0000001);
                }
                else{
                        pthread_mutex_unlock(&lock);
                        pthread_exit(NULL);
                }
        }
}

void* checkingChild1Msg(int pip[2]){
        char buf[MAXSIZE];
        for(;;){
                pthread_mutex_lock(&lock);
                if(checkPoint && (point < 3 && point > -3)){
                        if(read(pip[0],buf,MAXSIZE)>0){
                                point--;
                                printf("Child1 point = %d\n",point);
                        }
                        else{
                                printf("error read 1\n");
                        }
                        pthread_mutex_unlock(&lock);
                        sleep(0.0000001);
                }
                else{
                        pthread_mutex_unlock(&lock);
                        pthread_exit(NULL);
                }
        }
}
void* managePoint(int resultp[2][2]){
        char *buf1 = "Winner";
        char *buf2 = "Loser";
for(;;){
                pthread_mutex_lock(&lock);
                if(point >= 3 || point <= -3){
                        printf("finsih\n");
                        pthread_mutex_unlock(&lock);
                        checkPoint = false;
                        if(point >=3){
                                write(resultp[0][1],buf1,MAXSIZE);
                                write(resultp[1][1],buf2,MAXSIZE);
                                printf("끝남\n");
                        }
                        else{
                                write(resultp[0][1],buf2,MAXSIZE);
                                write(resultp[1][1],buf1,MAXSIZE);
                                printf("끈남2\n");
                        }
                        pthread_exit(NULL);
                }
                pthread_mutex_unlock(&lock);
        }
}
int parent(int pip[2][2],int resultp[2][2]){
        int i;
        pthread_t c1thread;
        pthread_t c2thread;
        pthread_t managethread;
        int thread1;
        int thread2;
        int thread3;
        void* t1;
        void* t2;
        void* t3;
        int ret1;
        int ret2;
        int ret3;
        int status1;
        int status2;
        int *p1;
int *p2;
        p1 = pip[0];
        p2 = pip[1];
        //      close(pip[0][1]);
        //      close(pip[1][1]);
        printf("parent process start\n");


        thread1 = pthread_create(&c1thread,NULL,checkingChild0Msg,p1);
        thread2 = pthread_create(&c2thread,NULL,checkingChild1Msg,p2);
        thread3 = pthread_create(&managethread,NULL,managePoint,resultp);

        pthread_join(&c1thread,&t1);
        pthread_join(&c2thread,&t1);
        pthread_join(&managethread,&t1);
        printf("finish parent\n");
}


void* sendMsgCtoP(int pip[2]){
        char buf[MAXSIZE];
        struct timespec del;
        for(;;){
                pthread_mutex_lock(&lock);
                if(checkPoint){
                        clock_gettime(CLOCK_MONOTONIC, &del);
                        double deltime = (del.tv_sec - middle.tv_sec) + (del.tv_nsec - middle.tv_nsec) / 1000000000.0;

                        if(deltime > 0.6){
                                printf("00000\n");
                                write(pip[1],msg1,MAXSIZE);
                                clock_gettime(CLOCK_MONOTONIC, &middle);
                        }

                        pthread_mutex_unlock(&lock);
                }
                else{
                        pthread_mutex_unlock(&lock);
                        pthread_exit(NULL);
                }
}
}

void* recvMsgPtoC(int resP[2]){
        char buf[MAXSIZE];
        for(;;){
                sleep(2);
                if(checkPoint){
                        pthread_mutex_lock(&lock);
                        if(read(resP[0],buf,MAXSIZE) >0){
                                printf("Child0 %s \n",buf);
                                //      pthread_mutex_lock(&lock);
                                checkPoint = false;
                                //      pthread_mutex_unlock(&lock);
                                pthread_exit(NULL);
                        }
                        else{
                                printf("read error 0\n");
                                pthread_exit(NULL);
                        }
                        pthread_mutex_unlock(&lock);
                }
                //      sleep(1);
        }

}

int child(int pip[2],int resultp[2]){
        int count;
        pthread_t p_send;
        pthread_t p_timer;
        pthread_t p_recv;
        int thread1;
        int timerCheck;
        int thread2;
        void* t2;
        void* t1;

        printf("child process start\n");
        clock_gettime(CLOCK_MONOTONIC,&middle);
thread1 =  pthread_create(&p_send,NULL,sendMsgCtoP,pip);
        thread2 = pthread_create(&p_recv,NULL,recvMsgPtoC,resultp);
        pthread_join(&p_send,&t1);
        pthread_join(&p_recv,&t1);
        printf("child end\n");
}


void* sendMsgCtoP1(int pip[2]){
        char buf[MAXSIZE];
        struct timespec del;
        for(;;){
                pthread_mutex_lock(&lock);
                if(checkPoint){

                        clock_gettime(CLOCK_MONOTONIC, &del);
                        double deltime = (del.tv_sec - middle.tv_sec) + (del.tv_nsec - middle.tv_nsec) / 1000000000.0;

                        if(deltime > 0.5){
                                printf("1111\n");
                                write(pip[1],msg1,MAXSIZE);
                                clock_gettime(CLOCK_MONOTONIC, &middle);
                        }


                        pthread_mutex_unlock(&lock);
                }
                else{
                        pthread_mutex_unlock(&lock);
                        pthread_exit(NULL);
                }
        }
}
void* recvMsgPtoC1(int resP[2]){
        char buf[MAXSIZE];
        for(;;){
                sleep(2);
                if(checkPoint){
                        pthread_mutex_lock(&lock);
                        if(read(resP[0],buf,MAXSIZE) >0){
                                printf("Child1 %s \n",buf);
                                pthread_mutex_lock(&lock);
                                checkPoint = false;
                                pthread_mutex_unlock(&lock);
                                pthread_exit(NULL);
                        }
                        else{
                                printf(
                                                "read error 0\n");
                                pthread_exit(NULL);
                        }
                        pthread_mutex_unlock(&lock);

                }
                //      sleep(1);
        }
}

int child1(int pip[2],int resultp[2]){
        int count;
        pthread_t p_send;
        pthread_t p_timer;
        pthread_t p_recv;
        int thread1;
        int timerCheck;
        int thread2;
        void* t2;
        void* t1;

        printf("child process start\n");
        clock_gettime(CLOCK_MONOTONIC,&middle);
        thread2 = pthread_create(&p_recv,NULL,recvMsgPtoC1,resultp);
        thread1 =  pthread_create(&p_send,NULL,sendMsgCtoP1,pip);                                             
 pthread_join(&p_send,&t1);
        pthread_join(&p_recv,&t1);
        printf("child end\n");
}

해당 코드를 짜고 나서 실행을 했더니 종료 Point(3점)를 달성하면 종료가 되어야 하는데 child process의 쓰레드에서 읽지를 못한다..

이유를 찾아봤더니 server process의 Point를 확인하는 쓰레드는 점수를 감지하고 child process의 쓰레드들에게 write를 잘 하지만 child process에서 read하는 쓰레드가 읽지도 않고 프로세스를 점령하고 써서 점수도 올라가지 않는다. 하.. 진짜 화나네

우선 해당 오류가 발생해서 더 수정이 필요하다...ㅠ

 

# 컴퓨터응용설계 팀프로젝트 

대망의 미루고 미뤄왔던 컴퓨터응용설계 팀프로젝트 마무리 시간이 왔다.

빨리 해치우고 시험공부 해야돼!!

 

저번에 서버에 연결하기 위해 시도 했던 API 호출을 오늘 다시 시도 해보려고 한다.

한참 걸릴거 같긴 한데 이참에 URL Session도 공부하게 되서 좋은 것 같다.

 

드디어 문제점을 발견했다...! 

 

원인은 서버에 접근하기 위해 사용하는 url에 문제가 있었다.

서버 접속은 되는데 데이터값이 안들어오고 404가 떠서 왜이러지 싶었는데 url을 확인해보니 중간에 (localhost/api/portnumber/startIndex/endIndex) 이런 형식으로 되어야하는데 중간에 api를 빼고 돌려서 실패했던 것이였다

서버를 새로 달아준 후에 코드를 수정하는데 서버에서 데이터를 잘 불러오지만 적용이 안되는 문제가 또 생겼다

(이놈의 문제는 계속 생기네..)

하나하나 코드를 분석하면서 1시간이 지나고..  찾아냈다!

 

내가 썻던 코드가 문제가 아니라 메인화면에서 버튼을 누르면 해당 버튼이 어떤 버튼인지 알려주는 값에 들어오는 값이 없어서 발생한 문제였다ㅠ (결국 삽질했네........)

 

내 담당 작업은 이렇게 모두 마무리가 되었다 헿

 

그치만 iOS앱 작업을 같이 하는 팀원이 아직 iOS코드를 다루는게 서툴러서 도움을 주어야한다.

도움을 줘야하는데.. 나도 잘 못하는 부분을 발견했다 ㅋㅋㅋ

 

시험끝나고 StackView를 이용한 Autolayout하는 실력을 많이 길러야할 것 같다.

아직 한참 부족하다 후.

 

해당 팀프로젝트 링크

https://github.com/HJ39/DragonGuard_ComAppDesign/tree/iOS

 

 

#참고한 사이트

  1. https://hcn1519.github.io/articles/2017-07/iOS_URLSession
  2. https://velog.io/@altmshfkgudtjr/Swift%EB%A1%9C-API-Request%EB%A5%BC-%EC%A0%84%EC%86%A1%ED%95%98%EA%B8%B0