반응형
///////CONCURRENT SERVER.c///////////
#include <stdlib.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>

#define SIZE sizeof(struct sockaddr_in)

int main(void)
{
	int sockfd_listen;
	int sockfd_connect;
	int client_len;
	
	char buff[80];
	//struct sockaddr_in server = {AF_INET, 5000, INADDR_ANY};
	struct sockaddr_in server,client;
	// server, client 소켓 정의 	


	bzero(&server, sizeof(server));//server 에 자신의 크기만큼 0 으로 clear
	server.sin_family = AF_INET; //IPv4
	server.sin_port = 5000; // 포트 설정 
	server.sin_addr.s_addr = inet_addr("192.168.56.128");
	
	printf("Server IP %s, Server Port : %u\n",inet_ntoa(server.sin_addr), server.sin_port);
	
	///////////////SOCKET///////////////////
	printf("skcket()\n");
	sockfd_listen =socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); //sockfd_listen = 3
	if(sockfd_listen < 0)
		printf("socket error\n");
	else
		printf("client sock%d\n",sockfd_listen);
	///////////////SOCKET///////////////////

	///////////////BIND/////////////////////
	//1. IPv4 address
	printf("bind()\n");
	if(bind(sockfd_listen, (struct sockaddr *)&server, SIZE))
		printf("bind error \n");
	///////////////BIND/////////////////////	

 	///////////////LISTEN///////////////////
	printf("listen()\n");
   	if(listen(sockfd_listen,5) == -1)
		printf("listen error \n");
 	///////////////LISTEN///////////////////

	
	while(1){
		bzero(&client, sizeof(client));
		client_len= sizeof(client);
		
 	///////////////ACCEPT////////////////////
		printf("wating for client\n");
		sockfd_connect = accept(sockfd_listen, (struct sockaddr *)&client, &client_len);
		//sockfd_connect = 4
		
		if(sockfd_connect < 0 )
			printf("accept error\n");
		else
			printf("sockfd connect %d\n",sockfd_connect);
		printf("accepted\n");
		printf("SERVER : Client IP : %s, Client Port : %u \n",inet_ntoa(client.sin_addr), 			ntohs(client.sin_port));
 	///////////////ACCEPT////////////////////
	
 	///////////////ACCEPT////////////////////

	//client 와 ACCEPT 하면 fork 하여 자식 프로세스와 통신 
		if(fork() == 0) { //child process
		
		//close
			close(sockfd_listen); // 3 close (parent)
			while(1){
				bzero(buff,sizeof(buff));
				recv(sockfd_connect, buff, sizeof(buff), 0 );
				printf("Server recv %s \n",buff);
				
				//"quit" exit
				if(strcmp(buff, "quit") == 0){//when BUFFER is a "quit" 
					printf("client exit \n");
					close(sockfd_connect); // 4 child process close
					exit(0); // child process exit
				}
				else	{	
					//fgets(buff, sizeof(buff), stdin); // can't chat is child , buff= hello --> "hello:server"
					strcat(buff, ":::SERVER"); // BUFFER 에 :SERVER 를 달아서 server 가 메시지를 받음을 확인
					send(sockfd_connect, buff, strlen(buff),0);
					continue; // goto 67 line (while)
				}
			}

			close(sockfd_connect); // 4
			exit(0); // child process exit
			
		}//end child
		
		//paraent process
		printf("close() sockfd_connect = %d\n", sockfd_connect); //4s
		close(sockfd_connect);

	}//end while
	
	//close(sockfd_listen);	
}

 

Server 의 특징 

  • Client 코드를 직접 배포

 

///////////CILENT.c///////////

#include <sys/socket.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <stdio.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <string.h>

#define SIZE sizeof(struct sockaddr_in)

int main(void)
{
	int sockfd;
	//char send_c, recv_c;
	char message[80];
	
	struct sockaddr_in server ;
	
	bzero(&server, sizeof(server));//0 clear
	server.sin_family = AF_INET; //IPv4
	server.sin_port = 5000;
	//server.sin_addr = INADDR_ANY;
	server.sin_addr.s_addr = inet_addr("192.168.56.128");
	printf("Client IP %s, Client Port : %u\n",inet_ntoa(server.sin_addr), server.sin_port);
	
/////////SOCKET//////////
	printf("skcket()\n");
	sockfd =socket(AF_INET, SOCK_STREAM, 0);
/////////SOCKET//////////
	
/////////CONNECT//////////
	printf("connect()\n");
	connect(sockfd, (struct sockaddr *)&server, SIZE);
/////////CONNECT//////////

/////////SEND_LOOP////////
	while(1){//send -> rcv
		printf("client message: ");
		fgets(message, sizeof(message), stdin);
		send(sockfd,message,strlen(message)-1,0);//fgets include 'enter' space so, -1
		
		bzero(message,sizeof(message));
		recv(sockfd, message, sizeof(message), 0);
		printf("client recv: %s \n",message);
	}
/////////SEND_LOOP////////	
	
	printf("close()\n");
	close(sockfd);
	
}
//////////FORK_PRACTICE/////////

#include <stdio.h>
#include <sys/type.h>
#include <unistd.h>

int main(void){

	pid_t pid;
//pid 선언
	
	pid=fork();
// fork 하여 자식 프로세스 생성
	
	if(pid>0){// 부모 프로세스 일때
		printf("parent process pid : %d \n",getpid());
		printf("parent process ppid : %d \n",getppid());
		printf("parent process child id : %d \n",pid);
		sleep(30);
	else if(pid==0){//자식 프로세스 일때
		printf("child process pid : %d \n",getpid());
		printf("child process ppid : %d \n",getppid());
	}
	else{
		prinf("fork error\n");
	}
}
반응형

'Lecture > System Software' 카테고리의 다른 글

[시소프] 3.SIC, SIC/XE  (0) 2021.10.31
[시소프] 2.Machine Level  (0) 2021.10.26
[시소프]1. Integer, Float  (0) 2021.10.25
반응형

SIC

  • virtual 환경에서 작동

  • SIC/XE 에서 SIC 함수 사용가능하지만 역은 안됨

Memory

  • 1byte = 8bits
  • 3byte = 1word
    • 'r' 시 p값이 3 씩 증가
  • 전체 $2^{15}$ bytes

Register

  • 각 레지스터는 1word
  • A(0) : 기본적인 산술연산 저장
  • X(1) : 주소저장, 계산
  • L(2) : 함수로 JUMP 시 돌아올 주소 저장
  • PC(8) : 다음 실행 명령어 저장
  • SW(9) : 산술연산 결과상태 필드플래그 저장

Data Format

  • Integer : 1word , binary
  • Character : 1byte ASCII code

명령어 포맷 구성

opcode(8) + X(1) + Address(15) = 24bit

주소지정방식

  • X = 0 → 직접주소지정
    • TA = Address
  • X = 1 → 인덱스 주소 지정방식
    • TA = Address + (X)

명령어 타입

  1. LD(Load)
    1. LDA m : A ← (m)
  2. ST(Store)
    1. STA m : m ← (A)
  3. 산술연산
    1. ADD, SUB,...
  4. COMP
    1. COMP m : A와 B를 비교후 LT, GT, EQ 를 SW에 저장
    2. TIX m : X+1 과 비교, 저장
  5. 조건부 점프
    1. J m : PC ← m
    2. JLT m : PC ← m , if cc set to <
    3. JRT m
    4. JEQ m
  6. 서브루틴 링커
    1. JSUB m : L ← (PC), PC ← m
    2. RSUB : PC(L)
  7. I /O
    1. TD
    2. WD
    3. RD
  8. 저장소 정의
    1. CHARA BYTE C'A'
    2. FOUR WORD 4

SIC/XE

  • SIC 보다 전체 메모리가 크다 ($2^{20}$)

Register

  • B(3) : 주소 지정
  • S(4) : 범용 레지스터
  • T(5) : 범용 레지스터
  • F(6) : 실수연산 (2word)

Data Format

  • Floating Point 추가
  • S(1) EXP (11) Fraction(36)

Instruction Format

  • Format 1 (1byte)
    • opcode(1byte)
  • Format 2 (2byte)
    • opcode(1byte) + reg1(4bit) + reg2(4)
  • Format 3 (3byte)
    • opcode(6) nixbpe (6) disp (12)
    • e = 0
      • b=1, p=0 : Base relative : TA = B + disp
      • b=0, p=1 : PC relative : TA = PC + disp
      • b=0, p=0 : direct : TA = disp
  • Format 4 (4byte)
    • opcode(6) nixbpe(6) address(20)
    • e = 1
      • n=0, i=1 : immediate Addressing : TA값을 주소로 사용 않고, 그 자체로 값사용
      • n=1, i=0 : indirect Addressing : TA를 간접주소사용
      • n=0,i=0 , n=1,i=1 : Simple Addressing : TA로 메모리 접근
반응형

'Lecture > System Software' 카테고리의 다른 글

[시소프] 4. 서버, 클라이언트, fork()  (0) 2021.11.23
[시소프] 2.Machine Level  (0) 2021.10.26
[시소프]1. Integer, Float  (0) 2021.10.25
반응형

Machine Level

CISC

  • 100가지 다른일에 대한 일대일 매핑 명령

RISC

  • CISC 보다 효율적이며 명령을 조합해서 사용

Code

  • Machine Code
    • bits 로 이루어진 기초방식 코드
  • Assembly Code
    • %ADD 처럼 가독성이 있는 코드방식

PC

  • 다음 명령어 주소저장

Register

  • 보통 16개, CPU 기억장치
  • 필요 Regi : Reserved
  • 여유 Regi : General

CC (Condition Code)

  • 정보 상태 저장

어셈블리 연산

  • 레지스터 혹은 메모리 내부에서 사칙연산
  • 메모리가 레지스터에서 LOAD, STORE
  • movq, etc...

어셈블러

  • .s 를 .o 로변환
  • 이진법으로 인코딩

Object Code

  • 3Byte 의 함수

데이터 이동(movq)

기본이동

  • movq (%rcx), %rax

Displacement

  • D(R) : Mem[Reg[R] + D]

Special Case

  • (Rb, Ri) : Mem[ Reg[Rb] + Reg[Ri] ]
  • D(Rb, Ri) : Mem[ Reg[Rb] + Reg[Ri] + D ]
  • (Rb, Ri, S) : Mem[ Reg[Rb] + S * Reg[Ri] ]
반응형

'Lecture > System Software' 카테고리의 다른 글

[시소프] 4. 서버, 클라이언트, fork()  (0) 2021.11.23
[시소프] 3.SIC, SIC/XE  (0) 2021.10.31
[시소프]1. Integer, Float  (0) 2021.10.25
반응형

이진법

  • 기본단위 : Bits
  • Byte = 8bits

정보는 모두 bit로 구성 (0,1)

  • Why? : 저장하기 쉬워서 (bistable)
  • 불확실한 상태에서도 신뢰적

2Byte 표현

  • Binary : 0000 0000 to 1111 1111
  • Deci : 0 to 255
  • Hex : 00 to FF

진법 표현 예시

  • Deci : 50
  • Octo : 050
  • Hex : 0x50

CPU 체제에따라 달라지는 데이터 타입의 용량

Bit 연산

Boolean

  • And : & : 둘다 T 일때 1
  • Or : | : 하나 이상 T 일때 1
  • Not : ~ : F 일때 1
  • XOR : ^ : 같을때 0, 다를때 1

집합

  • 크기 w 인 벡터 집합 {0, ... , w-1}

집합 연산자

  • & : 교집합
  • | : 합집합
  • ^ : 차집합
  • ~ : 여집합

Shift 연산자

→ 최상위 비트가 1이면 Arith 했을 시 1로 채워진다.

Unsigned

  • '-' 연산자를 사용할 수 없음
  • ex) 나이, 해, 년도..
  • 0-255
  • -128 ~ 127 (signed)

음수표현 방법

  1. Signed magnitude (실수)
    • 5 → 0000 0101
    • -5 → 1000 0101
    • 맨 앞 비트에 1을 더함
  2. 1's Complement (정수 x)
    • 5 → 0000 0101
    • -5 → 1111 1010
    • not 했을 시 값과 같음
  3. 2's Complement (정수)
    • 5 → 0000 0101
    • -5 → 1111 1011
    • 1's Complement 를 한 값에 마지막 비트에 1더함

unsigned 유의사항

  • 실수 자주 생김
  • 애매하게 될 수도 있음
  • 모듈러 연산시 사용함
  • 집합 표현시 사용함

Float

Floating Point : 포인트가 정확한 위치에 없다.

How to express Binary?

ex) 1011.101

  1. 1011 → 2^3 + 2 + 1 = 11
  2. .101 → frac{1}{2} + frac{1}{2^3} = 0.625
  • 11.625
  •  
  •  

Limitation

  1. 무한소수
  2. 너무 작거나 큰 수
    1. 수의 한계가 있음

→ IEEE

IEEE

  • 각기 다른 성능저하가 발생해 표준을 만든 기구
  • 반올림, overflow, underflow 에 대한 Standard 제시

형태

Normalized

반응형

'Lecture > System Software' 카테고리의 다른 글

[시소프] 4. 서버, 클라이언트, fork()  (0) 2021.11.23
[시소프] 3.SIC, SIC/XE  (0) 2021.10.31
[시소프] 2.Machine Level  (0) 2021.10.26

+ Recent posts