๋ฐฐ๊ฒฝ ํ
์ปค ๋ถํธ์บ ํ์์ ํํ๋ก์ ํธ๋ฅผ ์งํ ์ค์ด๋ค. ์ฐ๋ฆฌ ํ์ ์ฃผ์ ๋ ํน์ ์ธ๋ฌผ์๊ฒ ์๋ด์ ๋ฐ๋ ๊ฒ ๊ฐ์ ๋ํ๋ฅผ ํ ์ ์๋ ์ฑ๋ด์ ๋ง๋๋ ๊ฒ์ด๋ค. ์ด๋ฅผ ์ํด ํน์ ์ธ๋ฌผ์ด ํ๋ ๋ง์ ๋ชจ์ ๋ฐ์ดํฐ์
์ผ๋ก ๋ง๋ค๊ณ ์ด๋ฅผ RAG ๋ชจ๋ธ์ ์ ์ฉ์ํค๋ ค๊ณ ํ๋ค. ์์ ์ผ๋ก ๋จธ์คํฌ๊ฐ TED์์ ํ ์ธํฐ๋ทฐ๋ฅผ ํ
์คํธ๋ก ๊ฐ์ ธ์จ๋ค. OpenSearch ๋์ปค ์ปจํ
์ด๋๋ฅผ ์คํํ๋ค. ํ
์คํธ ๋ฐ์ดํฐ๋ฅผ ์๋ฒ ๋ฉํด์ OpenSearch์ ์ ์ฅํ๋ค. RAG ๋ชจ๋ธ์ด OpenSearch๋ฅผ ์ฟผ๋ฆฌํ์ฌ ๋๋ต์ ์์ฑํ๋ค. 1. ์ผ๋ก ๋จธ์คํฌ ์ธํฐ๋ทฐ ํ
์คํธ ๊ฐ์ ธ์ค๊ธฐ ์ ํ๋ธ์์ “์คํฌ๋ฆฝํธ ๋ณด๊ธฐ"๋ฅผ ํตํด ์ธํฐ๋ทฐ ์๋ง์ ๊ฐ์ ธ์จ๋ค.
122:03 2EM: ์ด ํฐ ํธ๋ญ์ ๋ชฐ๋ฉด์ ๋ง๋ ์๋๋ ์์ง์์ ๋ณด์์ฃ . 3CA: ์์ฃผ ๋ฉ์ง๋ค์. ์, ๊ทธ๋ผ ์ ๋ง ๊ต์ฅํ ์ฌ์ง์์ 422:09 5์กฐ๊ธ์ ๋ ๊ต์ฅํ ์ฌ์ง์ ๋ณด์ฃ . "์๊ธฐ์ ์ฃผ๋ถ๋ค"์ธ๊ฐ์์ ๋์ค๋ ๊ท์ฌ์ด ์ง ์ฌ์ง์ธ๋ฐ์. 622:15 7์ด๊ฒ ๊ฐ์๊ธฐ ์ ๋์จ๊ฑฐ์ฃ ? 8... ์ผ๋ก ๋จธ์คํฌ๊ฐ ํ ๋ง๋ง ์์ ์ ๋ฆฌํ๋ค.
1๋ค. ์ ์ค์ค๋ก๋ ๊ทธ ์ง๋ฌธ์ ์์ฃผ ํ๋ ํธ์
๋๋ค. 2์ ํฌ๋ LA์ ์งํ์ ๊ตฌ๋ฉ์ ๋ด๋ ค๊ณ ํ๋๋ฐ์. ์ด๋ ๊ตํต ์ฒด์ฆ์ ์ํ์ํค๊ธฐ ์ํ 33์ฐจ์ ๋คํธ์ํฌ์ ํฐ๋์ด ๋ ์๋ ์๋ ์๋ฐ์ ์ ๋ง๋ค๊ธฐ ์ํจ์
๋๋ค. 4๊ตํต ์ฒด์ฆ์ ์ค๋๋ ์ฐ๋ฆฌ์ ์ํผ์ ํํ ํฐ๋ ๋ฌธ์ ์ค์ ํ๋์
๋๋ค. 5์ธ๊ณ ๋ชจ๋ ์ฌ๋๋ค์๊ฒ ์ํฅ์ ๋ผ์น๊ณ ์์ฃ . ์ธ์์์ ๋๋ฌด๋ ๋ง์ ๋ถ๋ถ์ ๊ฐ์ ธ๊ฐ๋๋ค. 6... 2. OpenSearch ๋์ปค ์ปจํ
์ด๋ ์คํ 1docker create -it -p 9200:9200 -p 9600:9600 -e OPENSEARCH_INITIAL_ADMIN_PASSWORD={password} -e "discovery.type=single-node" -v opensearch_vol:/usr/share/opensearch/data --name opensearch opensearchproject/opensearch ์ค๋ช
-p 9200:9200 : OpenSearch HTTP ํฌํธ -p 9600:9600 : OpenSearch ๋ชจ๋ํฐ๋ง ํฌํธ -e OPENSEARCH_INITIAL_ADMIN_PASSWORD={password} : ์ด๊ธฐ ๋น๋ฐ๋ฒํธ ์ค์ -e “discovery.type=single-node” : ๋จ์ผ ๋
ธ๋๋ก ์คํ -v opensearch_vol:/usr/share/opensearch/data : ๋ฐ์ดํฐ ๋ณผ๋ฅจ ๋ง์ดํธ SSL ์ค๋ฅ ๋ฐ์๊ณผ ํด๊ฒฐ ํ์ง๋ง ์ ๋ช
๋ น์ด๋ก ์คํํ๋ฉด ์ปจํ
์ด๋ ๋ด๋ถ์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค
12024-07-05 22:15:12 Caused by: io.netty.handler.ssl.NotSslRecordException: not an SSL/TLS record: ... 22024-07-05 22:15:12 at io.netty.handler.ssl.SslHandler.decodeJdkCompatible(SslHandler.java:1314) ~[netty-handler-4.1.110.Final.jar:4.1.110.Final] 32024-07-05 22:15:12 at io.netty.handler.ssl.SslHandler.decode(SslHandler.java:1387) ~[netty-handler-4.1.110.Final.jar:4.1.110.Final] 42024-07-05 22:15:12 at io.netty.handler.codec.ByteToMessageDecoder.decodeRemovalReentryProtection(ByteToMessageDecoder.java:530) ~[netty-codec-4.1.110.Final.jar:4.1.110.Final] 52024-07-05 22:15:12 at io.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:469) ~[netty-codec-4.1.110.Final.jar:4.1.110.Final] 62024-07-05 22:15:12 ... 16 more ํ๋ก์ ํธ ๊ธฐ๊ฐ์ด ๊ธธ์ง ์๊ณ , ํด๋น ํฌํธ๋ ์ธ๋ถ์ ๋
ธ์ถํ ํ์๊ฐ ์์ผ๋ฏ๋ก SSL์ ๋๊ณ ์คํํ๋ ๊ฒ์ผ๋ก ํด๊ฒฐํ์๋ค.
1/usr/share/opensearch/config/opensearch.yml 2# ๋ณ๊ฒฝ ์ 3plugins.security.ssl.http.enabled: true 4# ๋ณ๊ฒฝ ํ 5plugins.security.ssl.http.enabled: false 3. ํ
์คํธ ๋ฐ์ดํฐ ์๋ฒ ๋ฉ ๋ฐ OpenSearch์ ์ ์ฅ RAG ์ธ์
์ ํด์ฃผ์ ๋ฉํ ๋์ด ์ง์ค ์ฝ๋๋ฅผ ์ ๊ทน! ์ฐธ๊ณ ํ์ฌ ์์ฑํ์๋ค.
OpenSearch ์ธ๋ฑ์ค ์์ฑ 1from opensearchpy import OpenSearch 2import torch 3from transformers import AutoTokenizer, AutoModel 4from langchain.text_splitter import RecursiveCharacterTextSplitter 5from langchain_community.document_loaders import TextLoader 6from langchain_community.vectorstores import OpenSearchVectorSearch 7 8INDEX_NAME = "elon_musk" 9FILE_NAME = "ted_elon_musk_script.txt" 10 11## OpenSearch ์ฐ๊ฒฐ ์ค์ 12client = OpenSearch( 13 hosts=[{"host": "localhost", "port": 9200}], http_auth=("admin", {password}) 14) 15 16## ํ
์คํธ ๋ฐ์ดํฐ ๋ถ๋ฌ์ค๊ธฐ 17loader = TextLoader(file_path=FILE_NAME, encoding="utf-8") 18docs = loader.load() 19 20text_splitter = RecursiveCharacterTextSplitter( 21 chunk_size=100, 22 chunk_overlap=0, 23 separators=["\n"], 24 length_function=len, 25) 26 27documents = text_splitter.split_documents(docs) 28 29# print(documents) 30 31## Embedding ๋ชจ๋ธ ์ ์ 32class MyEmbeddingModel: 33 def __init__(self, model_name): 34 self.tokenizer = AutoTokenizer.from_pretrained(model_name) 35 self.model = AutoModel.from_pretrained(model_name) 36 37 def embed_documents(self, doc): 38 inputs = self.tokenizer( 39 doc, return_tensors="pt", padding=True, truncation=True, max_length=512 40 ) 41 42 with torch.no_grad(): 43 outputs = self.model(**inputs) 44 embeddings = outputs.last_hidden_state.mean(dim=1).tolist() 45 46 return embeddings 47 48 def embed_query(self, text): 49 inputs = self.tokenizer( 50 [text], padding=True, truncation=True, return_tensors="pt", max_length=512 51 ) 52 with torch.no_grad(): 53 outputs = self.model(**inputs) 54 embeddings = outputs.last_hidden_state.mean(dim=1).tolist() 55 return embeddings 56 57 58## index ๊ตฌ์กฐ ์ ์ 59index_body = { 60 "settings": { 61 "analysis": { 62 "tokenizer": { 63 "nori_user_dict": { 64 "type": "nori_tokenizer", 65 "decompound_mode": "mixed", 66 "user_dictionary": "user_dic.txt", 67 } 68 }, 69 "analyzer": { 70 "korean_anlyzer": { 71 "filter": [ 72 "synonym", "lowercase", 73 ], 74 "tokenizer": "nori_user_dict", 75 } 76 }, 77 "filter": { 78 "synonym" :{ 79 "type": "synonym_graph", 80 "synonyms_path" : "synonyms.txt" 81 } 82 } 83 } 84 } 85} 86 87## Embedding ๋ชจ๋ธ ์์ฑ 88my_embedding = MyEmbeddingModel("monologg/kobert") 89 90## OpenSearch์ ๋ฐ์ดํฐ ์ฝ์
91vector_db = OpenSearchVectorSearch.from_documents( 92 index_name=INDEX_NAME, 93 body=index_body, 94 documents=documents, 95 embedding=my_embedding, 96 op_type="create", 97 opensearch_url="http://localhost:9200", 98 http_auth=("admin", {password}), 99 use_ssl=False, 100 verify_certs=False, 101 ssl_assert_hostname=False, 102 ssl_show_warn=False, 103 bulk_size=1000000, 104 timeout=360000, 105) 106 107result = vector_db.add_documents(documents, bulk_size=1000000) tokenizer๋ ํ๊ตญ์ด๋ฅผ ์ง์ํ๋ “nori_tokenizer"๋ฅผ ์ฌ์ฉํ์๋ค. embedding ๋ชจ๋ธ์ ์ ๊ฑฐ ๋ง๊ณ ๋ ์ฌ๋ฌ๊ฐ์ง๊ฐ ์กด์ฌํ๋๋ฐ, ์ด๋ค ๋ชจ๋ธ์ด ํ๋ก์ ํธ์ ๊ฐ์ฅ ๋ถํฉํ๋ ๋ชจ๋ธ์ธ์ง๋ ์คํ์ ํด๋ณผ ๊ฒ์ด๋ค. curl์ ํตํด localhost:9200/elon_musk/_search๋ก ์์ฒญ์ ๋ณด๋ด ์๋ฒ ๋ฉํ ๋ฐ์ดํฐ๊ฐ ์ ๋ค์ด๊ฐ๋์ง ํ์ธํ ์ ์๋ค. 4. RAG ๋ชจ๋ธ์ด OpenSearch๋ฅผ ์ฟผ๋ฆฌํ์ฌ ๋๋ต ์์ฑ 1from langchain.prompts import PromptTemplate 2from langchain.chains import LLMChain 3from langchain_openai import ChatOpenAI 4from opensearchpy import OpenSearch 5import os 6 7INDEX_NAME = "elon_musk" 8 9# ํ๊ฒฝ๋ณ์ ์ค์ 10os.environ["OPENAI_API_KEY"] = {api_key} 11 12llm = ChatOpenAI( 13 model_name="gpt-3.5-turbo", 14) 15 16prompt_template = PromptTemplate( 17 input_variables=["context", "question"], 18 template=""" 19Imagine you are {character_name}, 20a wise and experienced advisor. Given the context: "{context}", 21how would you respond to this inquiry: "{question}"?', 22(in korean) 23""", 24) 25 26 27llm_chain = LLMChain(llm=llm, prompt=prompt_template) 28 29client = OpenSearch( 30 hosts=["http://localhost:9200"], 31 http_auth=("admin", {password}), 32 use_ssl=False, 33 verify_certs=False, 34 ssl_assert_hostname=False, 35 ssl_show_warn=False, 36) 37 38def search_documents(query): 39 search_body = {"query": {"match": {"text": query}}} 40 response = client.search(index=INDEX_NAME, body=search_body) 41 hits = response["`its"]["hits"] 42 return [hit["_source"]["text"] for hit in hits] 43 44if __name__ == "__main__": 45 question = input("Enter your question\n") 46 search_results = search_documents(question) 47 48 print(search_results) 49 50 # context = " ".join(search_results) 51 context = "" 52 53 response = llm_chain.invoke({"character_name": INDEX_NAME, "context": context, "question": question}) 54 55 print (response["text"]) OpenSearch์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ฟผ๋ฆฌํ์ฌ RAG ๋ชจ๋ธ์ ๋ฃ์ด ๋๋ต์ ์์ฑํ๋ค. search_documents ํจ์๋ฅผ ํตํด OpenSearch์ ์ฟผ๋ฆฌ๋ฅผ ๋ณด๋ด๊ณ , ๊ทธ ๊ฒฐ๊ณผ๋ฅผ context๋ก ์ฌ์ฉํ๋ค. ๊ฒฐ๊ณผ ์ง๋ฌธ ํ
์ฌ๋ผ์ ๋ํด์ ์ด๋ป๊ฒ ์๊ฐํด?
RAG๋ฅผ ์ฌ์ฉํ์ง ์์์ ๋์ ๋๋ต ํ
์ฌ๋ผ๋ ํ์ ์ ์ธ ๊ธฐ์
์ผ๋ก์ ๋ฏธ๋๋ฅผ ํฅํ ๋น์ ์ ๊ฐ์ง๊ณ ์์ต๋๋ค. ๊ทธ๋ค์ ์ ๊ธฐ ์๋์ฐจ ๊ธฐ์ ๊ณผ ์๋์ง ์๋ฃจ์
์ ์ ์ธ๊ณ์ ์ผ๋ก ์ฃผ๋ชฉ๋ฐ๊ณ ์์ต๋๋ค. ํ
์ฌ๋ผ์ ํ์ ์ ์ธ ์ ๊ทผ ๋ฐฉ์๊ณผ ์ง์ ๊ฐ๋ฅํ ๋น์ฆ๋์ค ๋ชจ๋ธ์ ๋ํด ๋งค์ฐ ๊ธ์ ์ ์ผ๋ก ์๊ฐํ๊ณ ์์ต๋๋ค.
RAG๋ฅผ ์ฌ์ฉํ ๋ ์ ์ฉ๋ context [‘๊ธธ๊ฒ ๊ฐ ๊ฒ ๊ฐ์ง๋ ์์์.\n๊ทธ๋ฌ๋ค์. ์ ๋ ์ต๋ํ ์ค๋ซ๋์ ํ
์ฌ๋ผ์ ๋จธ๋ฌผ ์๊ฐ์ด์์.\n๊ทธ๋ฆฌ๊ณ ์ค๋น ์ค์ ์๋ ํฅ๋ฏธ๋ก์ด ์ผ๋ ๋ง๊ณ ์. ์์๋ค์ํผ, ๋ชจ๋ธ 3์ด ์ถ์ ์์ ์ด๊ณ ์.’, ‘์ฌํด ๋ง๊น์ง LA์์ ๋ด์๊น์ง\n์์ ์์จ ์ฃผํ์ผ๋ก ํก๋จํ๋ ๊ณํ์ ๋ง์ถฐ์ ์งํ ์ค์ด์์.\n์ฌ๋์ด ํ
์ฌ๋ผ์ ํ์ ์ด์ ๋๋ฅผ ์ก์ง ์๊ณ “๋ด์"์ ์ฐ์ผ๋ฉด ๊ทธ๋ฆฌ๋ก ๊ฐ๋ค๋ ๋ง์ด๋ค์.’, ‘๊ธธ๊ฒ ๊ฐ ๊ฒ ๊ฐ์ง๋ ์์์.\n๊ทธ๋ฌ๋ค์. ์ ๋ ์ต๋ํ ์ค๋ซ๋์ ํ
์ฌ๋ผ์ ๋จธ๋ฌผ ์๊ฐ์ด์์.\n๊ทธ๋ฆฌ๊ณ ์ค๋น ์ค์ ์๋ ํฅ๋ฏธ๋ก์ด ์ผ๋ ๋ง๊ณ ์. ์์๋ค์ํผ, ๋ชจ๋ธ 3์ด ์ถ์ ์์ ์ด๊ณ ์.’, ‘์ฌํด ๋ง๊น์ง LA์์ ๋ด์๊น์ง\n์์ ์์จ ์ฃผํ์ผ๋ก ํก๋จํ๋ ๊ณํ์ ๋ง์ถฐ์ ์งํ ์ค์ด์์.\n์ฌ๋์ด ํ
์ฌ๋ผ์ ํ์ ์ด์ ๋๋ฅผ ์ก์ง ์๊ณ “๋ด์"์ ์ฐ์ผ๋ฉด ๊ทธ๋ฆฌ๋ก ๊ฐ๋ค๋ ๋ง์ด๋ค์.’]
RAG๋ฅผ ์ฌ์ฉํ ๋์ ๋๋ต ์ ๋ ํ
์ฌ๋ผ๋ฅผ ๋งค์ฐ ๊ธ์ ์ ์ผ๋ก ์๊ฐํฉ๋๋ค. ํ
์ฌ๋ผ๋ ํ์ ์ ์ธ ๊ธฐ์ ๊ณผ ์ง์ ๊ฐ๋ฅํ ๋ฏธ๋๋ฅผ ์ํ ๋น์ ์ ๊ฐ์ถ ๊ธฐ์
์ผ๋ก์, ์์จ ์ฃผํ ๊ธฐ์ ์ ํตํด ์ฐ๋ฆฌ์ ์ถ์ ํ์ ํ๊ณ ์์ต๋๋ค. ๋ํ, ์ ๊ธฐ์ฐจ ์์ฅ์ ์ ๋ํ๊ณ ํ๊ฒฝ์ ์นํ์ ์ธ ์ฐจ๋์ ์ ๊ณตํ๋ ๋ฉ์ง ๊ธฐ์
์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ํ
์ฌ๋ผ์ ๋ฏธ๋๊ฐ ๋ฐ๊ณ ํฅ๋ฏธ๋ก์ด ์ผ๋ค์ด ๊ณ์ํด์ ์ผ์ด๋ ๊ฒ์ด๋ผ๊ณ ๋ฏฟ์ต๋๋ค.
๊ณ ์ฐฐ ํ์คํ RAG๋ฅผ ์ฌ์ฉํ์ง ์์์ ๋๋ ๊ฐ๊ด์ ์ด๊ณ ์ผ๋ฐ์ ์ธ ๋๋ต์ ํ๋ ๋ฐ๋ฉด, RAG๋ฅผ ์ฌ์ฉํ ๋๋ ํ
์ฌ๋ผ์ ๋ํด ๊ธ์ ์ ์ธ ์ผ๋ก ๋จธ์คํฌ์ ๋๋ต๊ณผ, ์์จ์ฃผํ ๊ธฐ์ ์ ์ธ๊ธํ๋ค๋ ๊ฒ์ ๋ฐ์ํ์ฌ ๋๋ต์ ์์ฑํ์๋ค. ๋ณธ ๋ด์ฉ์ 2023 MISRA-CPP ๊ฐ์ด๋๋ผ์ธ์ ๊ณต๋ถํ๋ฉด์ ๊ฐ๋
์ ์ ๋ฆฌํ ๊ฒ์ด๋ค.
์ฐธ์กฐ(Reference)์ ํฌ์ธํฐ(Pointer) ํฌ์ธํฐ(Pointer) ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ณ์
1// ๋ณ์ ์ ์ธ 2int a = 10; 3int* b = &a; // a์ ์ฃผ์๋ฅผ ์ ์ฅ 4 5// ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ 6void add(int* a, int* b) { 7 *a + *b; 8} 9 10add(&a, &b); ์ฐธ์กฐ(Reference) ๋ณ์์ ๋ณ์นญ์ ๋ถ์ฌํ๋ ๊ฒ
์ด๋ฆ์ผ๋ก ๋์์ ๊ฐ๋ฆฌํจ๋ค.
์ ์ฝ์ฌํญ
์ฐธ์กฐ๋ ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํํด์ผ ํ๋ค. ์ฐธ์กฐ๋ ํ ๋ฒ ์ด๊ธฐํ๋๋ฉด ๋ค๋ฅธ ๋ณ์๋ก ๋ณ๊ฒฝํ ์ ์๋ค. ์ฐธ์กฐ๋ NULL๋ก ์ด๊ธฐํํ ์ ์๋ค. 1// ๋ณ์ ์ ์ธ 2int a = 10; 3int& b = a; // a์ ๋ณ์นญ์ b๋ก ์ง์ 4 5// ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ 6void add(int& a, int& b) { 7 a + b; 8} 9add (a, b); ํ
ํ๋ฆฟ (Template) ํ
ํ๋ฆฟ์ ํจ์๋ ํด๋์ค๋ฅผ ์ ์ํ ๋, ํ์
์ ์ผ๋ฐํํ์ฌ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ
ํจ์ ํ
ํ๋ฆฟ 1template <typename T> 2T add(T a, T b) { 3 return a + b; 4} ํด๋์ค ํ
ํ๋ฆฟ 1template <typename T> 2class Point { 3public: 4 T x, y; 5 Point(T x, T y) : x(x), y(y) {} 6}; ํ
ํ๋ฆฟ ํน์ํ (Template Specialization) ํ
ํ๋ฆฟ์ ํน์ ํ์
์ ๋ํด ๊ตฌ์ฒดํํ๋ ๊ฒ
ํจ์ ํ
ํ๋ฆฟ ๋ช
์์ ํน์ํ 1template <typename T> 2T add(T a, T b) { 3 return a + b; 4} 5 6// int ํ์
์ ๋ํ ํน์ํ 7template <> 8int add(int a, int b) { 9 return a + b; 10} ํจ์ ํ
ํ๋ฆฟ ๋ถ๋ถ ํน์ํ 1template <typename T> 2T add(T a, T b) { 3 return a + b; 4} 5 6// ํฌ์ธํฐ ํ์
์ ๋ํ ๋ถ๋ถ ํน์ํ 7template <typename T> 8T add(T* a, T* b) { 9 return *a + *b; 10} ์์ฑ (Attribute) ์ปดํ์ผํ ๋ ํน์ ๋ฉ์์ง๋ฅผ ์์ฑํ๊ฑฐ๋ ์ปดํ์ผ๋ฌ๊ฐ ํน์ ๋์์ ์ํํ ์ ์๋๋ก ํจ
[[noreturn]] (~c++11) ํจ์๊ฐ ์ ์์ ์ผ๋ก ํธ์ถ์์๊ฒ ์ ์ด๊ถ์ ๋ฐํํ์ง ์์์ ๋ํ๋
[[noreturn]]์ผ๋ก ์ ์ธ๋ ํจ์๊ฐ ์ ์์ ์ธ ๋ฐํ์ ์๋ํ๋ ๊ฒฝ์ฐ undefined behavior ๋ฐ์ 1[[noreturn]] void error() { 2 throw "error"; 3} 4int32_t main() { 5 error(); 6 return 0; // dead code๋ก ์ต์ ํ๋ ์ ์์ 7} [[maybe_unused]] (~C++17) ์ฌ์ฉํ์ง ์๋ ๋ณ์, ํจ์, ๋งค๊ฐ๋ณ์, ํ์
์ ๋ํ ๊ฒฝ๊ณ ๋ฅผ ์ปดํ์ผ๋ฌ๊ฐ ๋ฌด์ํ๋๋ก ๋ช
์
1[[maybe_unused]] int a = 10; [[nodiscard]] (~C++17) ํจ์์ ๋ฐํ๊ฐ์ ๋ฌด์ํ๋ ๊ฒฝ์ฐ ์ปดํ์ผ๋ฌ๊ฐ ๊ฒฝ๊ณ ํ๋๋ก ๋ช
์
๋ฐ๋๋ก (void) ํํ๋ก ์บ์คํ
ํ์ฌ ๊ฒฝ๊ณ ๋ฅผ ์ต์ ํ ์ ์์ 1[[nodiscard]] int add(int a, int b) { 2 return a + b; 3} [[fallthrough]] (~C++17) switch๋ฌธ์์ case ๋ผ๋ฒจ์ ์ฌ์ฉํ ๋, break๋ฅผ ์ฌ์ฉํ์ง ์๋ ๊ฒฝ์ฐ ๊ฒฝ๊ณ ๋ฅผ ์ต์
1switch (a) { 2 case 1: 3 std::cout << "1" << std::endl; 4 [[fallthrough]]; // ์๋์ ์ผ๋ก 2๋ก ๋์ด๊ฐ๋ค๋ ๊ฒ์ ๋ช
์ 5 case 2: 6 std::cout << "2" << std::endl; 7 break; 8 default: 9 std::cout << "default" << std::endl; 10 break; 11} if constexpr (~C++17) compile time์ ์กฐ๊ฑด๋ฌธ์ ์ฒ๋ฆฌํ ์ ์๋๋ก ํจ
์กฐ๊ฑด์ด ๊ฑฐ์ง์ธ ๊ฒฝ์ฐ ํด๋น ๋ธ๋ก์ ์ปดํ์ผ๋์ง ์์ ํ
ํ๋ฆฟ๊ณผ ๋น์ทํ ๊ธฐ๋ฅ์ ์ํ ํ
ํ๋ฆฟ์ compile time์ ๋ชจ๋ ์ฝ๋๋ฅผ ์์ฑํ์ง๋ง if constexpr๋ ์กฐ๊ฑด์ ๋ฐ๋ผ ์ฝ๋๋ฅผ ์์ฑ 1template <typename T> 2void print(T value) { 3 if constexpr (std::is_same_v<T, int>) { 4 std::cout << "int: " << value << std::endl; 5 } else if constexpr (std::is_same_v<T, double>) { 6 std::cout << "double: " << value << std::endl; 7 } else { 8 std::cout << "unknown type" << std::endl; 9 } 10} Lambda (~C++11) ์ต๋ช
ํจ์๋ฅผ ์ ์ํ๋ ํํ์
๊ฐ๋จํ ํจ์๋ฅผ ์ ์ธํ ๋ ์ฌ์ฉ 1auto add = [](int a, int b) { 2 return a + b; 3}; Transient/Non-transient lambda Transient lambda ์ฆ์ ํธ์ถ๋๊ณ ์๋ฉธ๋๋ ๋๋ค ํจ์
1 int x = 10; 2 auto result = [](int x) { 3 return x * 2; 4 }(); // ์ฆ์ ํธ์ถ Non-transient lambda ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋์ด ์ฌ๋ฌ ๋ฒ ํธ์ถํ ์ ์๋ ๋๋ค ํจ์
1std::function<int32_t()> add = [](int a) { 2 return a + 10; 3}; 4 5int32_t result = add(10); Closure (~C++11) lambda expression์์ ์ธ๋ถ ๋ณ์์ ๋ํ ์ฐธ์กฐ๋ฅผ ์บก์ฒํ๋ ๋ฐฉ์
1int a = 10; 2auto add = [&a](int b) { 3 return a + b; 4}; Capture lamda ํจ์์์ ์ธ๋ถ ๋ณ์๋ฅผ ํจ์ ๋ด๋ถ๋ก ๊ฐ์ ธ์ค๋ ๊ฒ
lambda ํจ์๊ฐ ์ ์๋ ์์ ์ ์ธ๋ถ ๋ณ์๋ฅผ ์ฌ์ฉํ ์ ์๋๋ก ํจ
parameter ๋ฐฉ์๊ณผ์ ๋น๊ต
1// parameter ๋ฐฉ์ 2void addAndPrint(int a, int b) { 3 std::cout << a + b << std::endl; 4} 5 6int main() { 7 int x = 10; 8 int y = 20; 9 addAndPrint(x, y); // ๋งค๋ฒ ํธ์ถํ ๋ ๊ฐ์ ์ ๋ฌํด์ผ ํจ 10} 1// capture ๋ฐฉ์ 2int x = 10; 3int y = 20; 4 5auto addAndPrint = [&x, &y]() { // ์ธ๋ถ ๋ณ์ x์ y๋ฅผ ์ฐธ์กฐ๋ก ์บก์ฒ 6 std::cout << x + y << std::endl; 7}; 8 9addAndPrint(); // ๋งค๊ฐ๋ณ์ ์์ด๋ ์ธ๋ถ ๋ณ์์ ์ ๊ทผ ๊ฐ๋ฅ Capture List [&] : ๋ชจ๋ ์ธ๋ถ ๋ณ์๋ฅผ ์ฐธ์กฐ๋ก ์บก์ฒ [=] : ๋ชจ๋ ์ธ๋ถ ๋ณ์๋ฅผ ๊ฐ์ผ๋ก ์บก์ฒ [a] : ๋ณ์ a๋ฅผ ๊ฐ์ผ๋ก ์บก์ฒ [&a] : ๋ณ์ a๋ฅผ ์ฐธ์กฐ๋ก ์บก์ฒ Escape Sequence ๋ฌธ์์ด ๋ฆฌํฐ๋ด์์ ํน์ ๋ฌธ์๋ฅผ ํํํ๊ธฐ ์ํด ์ฌ์ฉํ๋ ๋ฌธ์์ด
Escape Sequence Description \' ์์ ๋ฐ์ดํ \" ํฐ ๋ฐ์ดํ \? ๋ฌผ์ํ \\ ์ญ์ฌ๋์ \a ๋ฒจ ์๋ฆฌ \b ๋ฐฑ์คํ์ด์ค \f ํผ ํผ๋ \n ๊ฐํ \r ์บ๋ฆฌ์ง ๋ฆฌํด \t ์ํ ํญ \v ์์ง ํญ \0 ๋ ๋ฌธ์ \nnn 8์ง์ \xnn 16์ง์ Encoding C++์์๋ ๋ฌธ์ ๋ฆฌํฐ๋ด์ ์ ๋์ฌ๋ฅผ ๋ถ์ฌ ์ธ์ฝ๋ฉ์ ์ง์ ํ ์ ์์
Encoding Prefix Example Literal Wide L L'A' Literal UTF-8 u8 u8'A' Literal UTF-16 u u'A' Literal UTF-32 U U'A' ASCII none '\x41' UTF-8 none '\xC3\xA9' Unicode (UTF-16) none '\u0041' Unicode (UTF-32) none '\U00000041' Cast Operator C++์์๋ ๋ค์ํ ํ๋ณํ ์ฐ์ฐ์๋ฅผ ์ ๊ณต
static_cast ๋
ผ๋ฆฌ์ ์ผ๋ก ํ๋ณํ์ด ๊ฐ๋ฅํ ๊ฒฝ์ฐ์ ์ฌ์ฉ
๊ธฐ๋ณธ ํ์
๊ฐ์ ๋ณํ, ํฌ์ธํฐ/์ฐธ์กฐ ๊ฐ์ ๋ช
์์ ๋ณํ์ ์ฌ์ฉ ์ปดํ์ผ ์์ ์ ๊ฒ์ฆ -> ๋
ผ๋ฆฌ์ ์ผ๋ก ๋ง์ง ์์ ๊ฒฝ์ฐ ์ปดํ์ผ ์๋ฌ ๋ฐ์ 1int a = 10; 2double b = static_cast<double>(a); dynamic_cast ์์ ๊ด๊ณ์์์ ํ๋ณํ์ ์ํด ์ฌ์ฉ
๋ฐํ์ ์์ ์ ์์ ํ ํ๋ณํ์ ๋ณด์ฅ ๋ฐ๋์ ๊ฐ์ ํจ์๊ฐ ์๋ ํด๋์ค์์๋ง ์ฌ์ฉ ๊ฐ๋ฅ ๋ค์ด์บ์คํ
์, ํ๋ณํ์ด ๋ถ๊ฐ๋ฅํ ๊ฒฝ์ฐ nullptr์ ๋ฐํ 1class Base { 2public: 3 virtual void print() {} 4}; 5class Derived : public Base { 6public: 7 void print() override {} 8}; 9 10Base* base = new Derived(); 11Derived* derived = dynamic_cast<Derived*>(base); // ์์ ํ ๋ค์ด์บ์คํ
const_cast ํฌ์ธํฐ ๋๋ ์ฐธ์กฐํ์ const ์์ฑ์ ์ ๊ฑฐํ๊ธฐ ์ํด ์ฌ์ฉ
์์ํ -> ๋น์์ํ์ผ๋ก ๋ณํ ๋ถ๋ณ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๋ ๋ฐ ์ฌ์ฉํ๋ฉด undefined behavior ๋ฐ์ 1const int a = 10; 2int* b = const_cast<int*>(&a); reinterpret_cast ํฌ์ธํฐ ํ๋ณํ์ด๋ ๋น๋
ผ๋ฆฌ์ ํ๋ณํ์ ์ํด ์ฌ์ฉ
๋ฉ๋ชจ๋ฆฌ ๋ ์ด์์์ ๊ธฐ๋ฐ์ผ๋ก ํฌ์ธํฐ๋ฅผ ๋ณํ undefined behavior๋ฅผ ๋ฐ์์ํฌ ์ ์์ ์์ ํ ๋ค๋ฅธ ํ์
์ผ๋ก ๋ณํ์ด ๊ฐ๋ฅํ์ง๋ง, ์์ ์ฑ์ ๋ณด์ฅํ์ง ์์ 1int a = 10; 2int* b = reinterpret_cast<int*>(&a); constexpr (~C++11) ์ปดํ์ผ ์๊ฐ์ ํ๊ฐ๋๋ ํํ์์ ์์ฑํ๊ธฐ ์ํด ์ฌ์ฉ
๋ณ์ compile time ์์์๋ง ์ฌ์ฉ ๊ฐ๋ฅ 1constexpr int num1 = 10; 2 3int a = 20; 4constexpr int num2 = a; // error: ๋ณ์ a๋ runtime์ ๊ฒฐ์ ๋๋ฏ๋ก ์ฌ์ฉ ๋ถ๊ฐ ํจ์ ํจ์๊ฐ compile time์ ์คํ๋๋๋ก ๋ณด์ฅ ์ธ์ ๊ฐ์ด compile time ์์์ธ ๊ฒฝ์ฐ -> constexpr ํจ์๋ก ๋์ ์ธ์ ๊ฐ์ด compile time ์์๊ฐ ์๋ ๊ฒฝ์ฐ -> constexpr ํจ์๋ก ๋์ body์์ ๋ถ๊ฐ๋ฅํ ๊ตฌ๋ฌธ goto try-catch ์ด๊ธฐํ ์ํ์ด ์๋ ๋ณ์ ์ ์ธ ๋ฆฌํฐ๋ด ํ์
์ด ์๋ ๋ณ์ ์ ์ธ static ๋ณ์ ์ ์ธ tls(thread local storage) ๋ณ์ ์ ์ธ ๋ฑ… 1constexpr int fibonacci(const int n) { 2 if (n <= 1) return n; 3 return fibonacci(n - 1) + fibonacci(n - 2); 4} 5fibonacci(10); // compile time์ ๋ค ๊ณ์ฐ๋์ด์ 55๋ก ๋์ฒด๋จ lvalue, rvalue ์ฐธ์กฐ lvalue ๊ฐ์ฒด๋ฅผ ๊ฐ๋ฆฌํค๋ ๋ฉ๋ชจ๋ฆฌ ์์น๋ฅผ ๋ํ๋ด๋ ํํ์
lvalue ์ฐธ์กฐ 1int b = 10; 2int& a = b; // a๋ b์ ์ฐธ์กฐ์ (lvalue ์ฐธ์กฐ) 3a = 20; ๋ฉค๋ฒ ํจ์์์์ ์ฌ์ฉ ์์ 1class MyClass { 2public: 3 void show() & { 4 std::cout << "lvalue function called (object is lvalue)" << std::endl; 5 } 6}; 7 8MyClass obj; 9obj.show(); // lvalue ๊ฐ์ฒด์์ ํธ์ถ rvalue ๋ฉ๋ชจ๋ฆฌ์ ์์น์ ํ ๋น๋ ๊ฐ์ ๋ํ๋ด๋ ํํ์
์ฃผ์๊ฐ ์๊ฑฐ๋, ์์๋ก ํ ๋น๋ ๊ฐ
์ฃผ๋ก ํํ์์ด๋ ํจ์์ ๋ฐํ๊ฐ์ด๋ค.
move semnatics๋ฅผ ์ฌ์ฉํ์ฌ ์์์ ํจ์จ์ ์ผ๋ก ์ด๋์ํค๋๋ฐ ์ฌ์ฉํ๋ค.
rvalue ์ฐธ์กฐ (~C++11)
1int&& a = 10; 2 3void show() && { 4 std::cout << "rvalue function called (object is rvalue)" << std::endl; 5} ๋ฉค๋ฒ ํจ์์์์ ์ฌ์ฉ ์์ 1class MyClass { 2public: 3 void show() && { // rvalue์์๋ง ํธ์ถ ๊ฐ๋ฅ 4 std::cout << "rvalue function called (object is rvalue)" << std::endl; 5 } 6}; 7 8MyClass().show(); // rvalue ๊ฐ์ฒด์์ ํธ์ถ ๊ฐ์ํจ์ ์์ ๊ด๊ณ์์ ๋์ ๋ฐ์ธ๋ฉ์ ์ํด ์ฌ์ฉ
๊ฐ์ ํจ์๋ฅผ ๊ฐ์ง ํด๋์ค๋ฅผ ๋คํ์ฑ ํด๋์ค(polymorphic class)๋ผ๊ณ ํจ ์์ ๊ฐ์ ํจ์๋ฅผ ๊ฐ์ง ํด๋์ค๋ฅผ ์ถ์ ํด๋์ค(abstract class)๋ผ๊ณ ํจ virtual ์ง์ ์ ๊ฐ์ ํจ์ : ์ค๋ฒ๋ผ์ด๋ฉ์ด ์ ํ์ ์ ์์ ๊ฐ์ ํจ์ : ์ค๋ฒ๋ผ์ด๋ฉ์ด ํ์์ 1class Base { 2public: 3 // ๊ฐ์ํจ์ 4 virtual void show() { 5 std::cout << "Base::show()" << std::endl; 6 } 7 8 // ์์ ๊ฐ์ํจ์ 9 virtual void print() = 0; 10}; override ์ง์ ์ ์ค๋ฒ๋ผ์ด๋ฉ์ ๋ช
์์ ์ผ๋ก ํ์
1class Derived : public Base { 2public: 3 void show() override { 4 std::cout << "Derived::show()" << std::endl; 5 } 6}; final ์ง์ ์ ์์์ ๋ฐฉ์งํ๋ ํค์๋
ํด๋์ค์ ์ฌ์ฉ : ์์์ ๋ฐฉ์ง ํจ์์ ์ฌ์ฉ : ์ค๋ฒ๋ผ์ด๋ฉ์ ๋ฐฉ์ง 1// ์์์ ๋ฐฉ์ง 2class Car final { ... }; 3 4// ์์๊ณผ ๊ฐ์ด ์ฐ์ด๋ ๊ฒฝ์ฐ 5class Derived final : public Base { ... }; 6 7class Base { 8public: 9 // ์ค๋ฒ๋ผ์ด๋ฉ์ ๋ฐฉ์ง 10 void show() final { ... } 11}; enum vs enum class enum ๊ธฐ์กด์ C ์คํ์ผ ์ด๊ฑฐํ
์ปดํ์ผ ์์ ์ ์ ์ํ ์์๋ก ๋ณํ -> ์ฑ๋ฅ ์ ํ๊ฐ ์์ ๋ค๋ฅธ enum ์์ญ์ด๋ผ๋ ๋ณ์๋ช
์ด ์ค๋ณต๋๋ฉด ์ถฉ๋ ๋ฐ์ 1enum Color { 2 RED, 3 GREEN, 4 BLUE 5}; 6Color color = RED; enum class (~C++11) enum์ ํ์ฅ๋ ๋ฒ์
๋ฌต์์ ํ๋ณํ์ด ๋ถ๊ฐ๋ฅ -> ๋ช
์์ ํ๋ณํ ํ์ enum ์์ญ์ด ๊ฒฉ๋ฆฌ๋์ด ๋ณ์๋ช
์ด ์ค๋ณต๋์ด๋ ์ถฉ๋์ด ๋ฐ์ํ์ง ์์ 1enum class Color { 2 RED, 3 GREEN, 4 BLUE 5}; 6Color color = Color::RED; explicit ์ง์ ์ ๋จ์ผ ์ธ์ ์์ฑ์์ ์์์ ํ๋ณํ์ ๋ฐฉ์งํ๊ธฐ ์ํด ์ฌ์ฉ
๋จ์ผ ์ธ์ ์์ฑ์ ์์ ์ฌ์ฉ 1class MyClass { 2public: 3 explicit MyClass(int a) : a(a) {} 4} 5 6MyClass obj = 10; // error: ์์์ ํ๋ณํ ๋ถ๊ฐ 7MyClass obj(10); // ok ์จ๊ฒจ์ง friend ํจ์ ํด๋์ค์ private ๋ฉค๋ฒ์ ์ ๊ทผํ ์ ์๋๋ก ํ๋ ํจ์
๋ฉค๋ฒํจ์๊ฐ ์๋์ง๋ง ํด๋์ค์ private ๋ฉค๋ฒ์ ์ ๊ทผํ ์ ์์ ํด๋์ค ๋ด๋ถ์ ์ ์ํด์ผ ํจ ADL๋ก๋ง ํธ์ถ ๊ฐ๋ฅ 1namespace MyMath { 2 class Point { 3 int x, y; 4 5 Point(int x, int y) : x(x), y(y) {} 6 7 friend void operator+(Point& a, Point& b) { 8 a.x += b.x; 9 a.y += b.y; 10 } 11 }; 12} 13int32_t main() { 14 MyMath::Point a(10, 20); 15 MyMath::Point b(30, 40); 16 17 a + b; 18} ADL (Argument Dependent Lookup) ํจ์ ํธ์ถ ์ ์ธ์์ ๋ค์์คํ์ด์ค๋ฅผ ๊ฒ์ํ์ฌ ํจ์๋ฅผ ์ฐพ๋ ๊ฒ
1namespace MyMath { 2 struct Point { 3 int x, y; 4 Point(int x, int y) : x(x), y(y) {} 5 }; 6 7 void operator+(Point& a, Point& b) { 8 a.x += b.x; 9 a.y += b.y; 10 } 11} 12int32_t main() { 13 MyMath::Point a(10, 20); 14 MyMath::Point b(30, 40); 15 16 a + b; // ADL๋ก ์ธํด MyMath::operator+ ํจ์ ํธ์ถ 17 MyMath::operator+(a, b); // ADL์ด ์์๋ค๋ฉด ๋ช
์์ ์ผ๋ก ํธ์ถ 18} std::variant (~C++17) ์ฌ๋ฌ ํ์
์ค ํ๋๋ฅผ ์ ์ฅํ๋ ํด๋์ค
union๊ณผ ๋๊ฐ์ด ๋์ํ์ง๋ง, type-safeํจ 1std::variant<int, double, std::string> value = 1; 2cout << std::get<int>(value) << endl; // 1 3 4value = 3.14; 5cout << std::get<double>(value) << endl; // 3.14 6 7value = "hello"; 8cout << std::get<std::string>(value) << endl; // hello ๋ฉค๋ฒ, ๋น๋ฉค๋ฒ ํจ์ index() : ํ์ฌ ์ ์ฅ๋ ํ์
์ ์ธ๋ฑ์ค๋ฅผ ๋ฐํ holds_alternative<T>() : ํน์ ํ์
์ด ์ ์ฅ๋์ด ์๋์ง ํ์ธ get<T>() : ํน์ ํ์
์ ๊ฐ์ ๋ฐํ (ํ์
์ด ๋ง์ง ์์ผ๋ฉด ์์ธ ๋ฐ์) get_if<T>() : ํน์ ํ์
์ ๊ฐ์ ๋ฐํ (ํ์
์ด ๋ง์ง ์์ผ๋ฉด nullptr ๋ฐํ) visit() : ์ ์ฅ๋ ํ์
์ ๋ชฐ๋ผ๋ ์ฒ๋ฆฌ ๊ฐ๋ฅ 1std::variant<int, double, std::string> value; 2 3value = "hello"; 4value.index(); // 2 (ํ์
์์๋๋ก index ํ์ฑ) 5 6std::holds_alternative<double>(value); // true 7 8value = 1; 9std::get<int>(value); // 1 10std::get_if<int>(&value); // 1 11 12std::visit([](auto& arg) { 13 std::cout << arg << std::endl; 14}, value); 1. ํด๋์ค ์ ์ 1@Getter 2@RequiredArgsConstructor 3public class ExceptionResponse { 4 private final LocalDateTime timestamp = LocalDateTime.now(); // 2023-08-01T00:00:57.5995502 5 private final int status; // 400 6 private final String error; // MethodArumentNotValidException 7 private final String message; // ์ด๋ฉ์ผ ํ์์ด ์๋๋๋ค 8 private final String path; // /api/customer 9} ๋ด๊ฐ ์ํ๋ ๋ฐฉ์๋๋ก ํด๋์ค๋ฅผ ์ ์ํ๋ค, ์ฃผ์์๋ ํด๋น ํ๋์ ์์๋ฅผ ์ ์ด๋์๋ค 2. ResponseEntity ๋ง๋๋ ํจ์ ์ ์ 1private ResponseEntity<ExceptionResponse> handleException(HttpStatus status, Exception e, HttpServletRequest request) { 2 ExceptionResponse response = new ExceptionResponse( 3 status.value(), e.getClass().getSimpleName(), e.getMessage(), request.getRequestURI()); 4 return new ResponseEntity<>(response, status); 5} ์์ธ ์ฒ๋ฆฌํ ๋๋ง๋ค ExceptionResponse ๊ฐ์ฒด๋ฅผ ๋ง๋ค๋ฉด ๋ฐ๋ณต๋๋ ์ฝ๋๊ฐ ๋ง์ด ์๊ฒจ ํจ์๋ก ๋ง๋ค์๋ค ์์ธ๊ฐ ๋ฐ์ํ ์ํฉ์ ๋ฐ๋ผ์ HttpStatus๋ฅผ ๋ค๋ฅด๊ฒ ์ง์ ํ ์ ์๋๋ก ํจ์์ ์ธ์๋ก ๋ฐ์๋ค 3. ์์ธ ์ฒ๋ฆฌ 1@ExceptionHandler(NoSuchElementException.class) 2public ResponseEntity<ExceptionResponse> handleNoSuchElementException(NoSuchElementException e, HttpServletRequest request) { 3 return handleException(HttpStatus.NOT_FOUND, e, request); 4} ๋ณธ ํจ์๋ @RestControllerAdvice๊ฐ ๋ถ์ ํด๋์ค์ ์ ์๋์๋ค ์ง์ ์ ์ํ ํจ์๋ฅผ ํธ์ถํด์ ResponseEntity๋ฅผ ๋ง๋ค์ด ๋ฐํํ๋ค ์ ๋ฆฌ ์์ ์์๋ NoSuchElementException์ด ๋ฐ์ํ์ ๋, HTTP ์ํ์ฝ๋๋ 404, body๋ ๋ด๊ฐ ์ ์ํ๋๋ก ์๋ตํ๋ ์ฝ๋์ด๋ค REST Api์์ ์ผ๊ด์ฑ์๊ณ ๊ฐ๊ฒฐํ ์๋ต์ ๋ณด๋ด๊ธฐ ์ํด ํ๋ฒ ์ ๋ฆฌํด๋ณด์๋ค ๋ณผ๋์ฒด์ ๊ฐ๋
์ ๊ธฐ์ถ ๋ฌธ์ ์์ ๋ฑ์ฅ, ๋๋จธ์ง ๊ฐ๋
์ ๋ชจ์๊ณ ์ฌ์์ ๋ฑ์ฅ SW ๊ณตํ ๊ด๋ จ ๊ฐ๋
SOLID ์์น S : ๋จ์ผ ์ฑ
์ ์์น (SRP) O : ๊ฐ๋ฐฉ ํ์ ์์น (OCP) : ํ์ฅ์๋ ์ด๋ ค ์์ด์ผ ํ๊ณ , ์์ ์๋ ๋ซํ ์์ด์ผ ํ๋ค๋ ์์น L : ๋ฆฌ์ค์ฝํ ์นํ ์์น (LSP) : ์๋ธํ์
์ ์ธ์ ๋ ์์ ์ ๊ธฐ๋ฐ ํ์
์ผ๋ก ๊ต์ฒดํ ์ ์์ด์ผ ํ๋ค๋ ์์น I : ์ธํฐํ์ด์ค ๋ถ๋ฆฌ ์์น (ISP) D : ์์กด ์ญ์ ์์น (DIP) : ์ถ์ํ์ ์์กดํด์ผ ํ๋ค๋ ์์น SOA(Service-Oriented Architecture) : ์๋น์ค ์งํฅ ์ํคํ
์ฒ Walk Through : ๊ฒํ ์๋ฃ๋ฅผ ํ์ ์ ์ ๋ฐฐํฌํด์ ์ฌ์ ๊ฒํ ํ ํ ์งง์ ์๊ฐ ๋์ ํ์๋ฅผ ์งํํ๋ ํํ๋ก ๋ฆฌ๋ทฐ๋ฅผ ํตํด ์ค๋ฅ๋ฅผ ๊ฒ์ถํ๊ณ ๋ฌธ์๋ก ๋ง๋๋ ๊ธฐ๋ฒ ์ ํ ๋ช
์ธ ๊ธฐ๋ฒ : ์ฌ์ฉ์์ ์๊ตฌ๋ฅผ ํํํ ๋ ์ํ์ ์๋ฆฌ์ ํ๊ธฐ๋ฒ์ผ๋ก ์์ ํ๋ ๊ธฐ๋ฒ ๋์์ธ ํจํด Abstract Factory Pattern : ์์ฑ ํจํด; ๊ฐ์ฒด ์์ฑ์ ๋ํ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํ๊ณ , ๊ตฌ์ฒด์ ์ธ ํด๋์ค๋ ์๋ธํด๋์ค์์ ์ ์ํ๋ ํจํด Decorator Pattern : ๊ตฌ์กฐ ํจํด; ๊ฐ์ฒด์ ์ถ๊ฐ์ ์ธ ์ฑ
์์ ๋์ ์ผ๋ก ๋ถ์ฌํ๋ ํจํด Memento Pattern : ํ์ ํจํด; ๊ฐ์ฒด์ ์ํ๋ฅผ ์ ์ฅํ๊ณ ๋ณต์ํ๋ ํจํด Factory Method Pattern : ์์ฑ ํจํด; ๊ฐ์ฒด ์์ฑ์ ๋ํ ์ธํฐํ์ด์ค๋ฅผ ์ ๊ณตํ๊ณ , ๊ตฌ์ฒด์ ์ธ ํด๋์ค๋ ์๋ธํด๋์ค์์ ์ ์ํ๋ ํจํด Bridge Pattern : ๊ตฌ์กฐ ํจํด; ์ถ์ํ์ ๊ตฌํ์ ๋ถ๋ฆฌํ์ฌ ๋
๋ฆฝ์ ์ผ๋ก ํ์ฅํ ์ ์๋๋ก ํ๋ ํจํด Observer Pattern : ํ์ ํจํด; ๊ฐ์ฒด์ ์ํ ๋ณํ์ ๋ฐ๋ผ ๋ค๋ฅธ ๊ฐ์ฒด์ ์๋ฆผ์ ๋ณด๋ด๋ ํจํด Proxy Pattern : ๊ตฌ์กฐ ํจํด; ๋ค๋ฅธ ๊ฐ์ฒด์ ๋ํ ์ ๊ทผ์ ์ ์ดํ๋ ๋๋ฆฌ ๊ฐ์ฒด๋ฅผ ์ ๊ณตํ๋ ํจํด Iterator Pattern : ํ์ ํจํด; ์ปฌ๋ ์
๊ฐ์ฒด์ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ๋
ธ์ถํ์ง ์๊ณ ์์ฐจ์ ์ผ๋ก ์ ๊ทผํ ์ ์๋๋ก ํ๋ ํจํด ์ด์ ํ์ : ๋ฐ์ดํฐ๋ฅผ ๋ฐ์ดํฐ๋ฒ ์ด์ค์ ์ ์ฅํ ๋ ๋ถํ์ํ๊ฒ ์ค๋ณต๋์ด ๋ฆด๋ ์ด์
์กฐ์์ ์๊ธฐ์น ๋ชปํ ๊ณค๋ํ ํ์์ผ ๋ฐ์ํ๋ ํ์ ๋ฒ๋ค์ด ์ฐจํธ : ๋จ์ ์์
๋์ ์๊ฐ์ ๋ฐ๋ผ ํ์ํ์ฌ ์งํ ์ํฉ์ ์๊ฐ์ ์ผ๋ก ๋ํ๋ด๋ ์ฐจํธ COCOMO : ๋ณดํด์ด ์ ์ํ ํ๋ก๊ทธ๋จ ๊ท๋ชจ์ ๋ฐ๋ผ ๋น์ฉ์ ์ฐ์ ํ๋ ๋ฐฉ์ (์กฐ์งํ, ๋ถ๋ฆฌํ, ์๋ฒ ๋๋ํ) CPM : ํ๋ก์ ํธ์ ์์
์ ๋คํธ์ํฌ ํํ๋ก ํํํ์ฌ ์ ์ฒด ํ๋ก์ ํธ์ ์ผ์ ์ ๊ณ์ฐํ๋ ์๊ณ ๋ฆฌ์ฆ PERT : ๋น๊ด์น, ์ค๊ด์น, ๋๊ด์น์ 3์ ์ถ์ ๋ฐฉ์์ ํตํด ์ผ์ ์ ๊ด๋ฆฌํ๋ ๊ธฐ๋ฒ ๊ฒฐํจ ์ง์ค : 20%์ ๋ชจ๋์์ 80%์ ๊ฒฐํจ์ด ๋ฐ์ํ๋ค๋ ์๋ฆฌ ์ด์ถฉ์ ํจ๋ฌ๋
์ค : ๋์ผํ ํ
์คํธ ์ผ์ด์ค๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ์คํํ๋ฉด ์๋ก์ด ๊ฒฐํจ์ ๋ฐ๊ฒฌํ์ง ๋ชปํ๋ค๋ ์๋ฆฌ ๋ฐฐ์น ๋ค์ด์ด๊ทธ๋จ : ์์คํ
์ ๋ฌผ๋ฆฌ์ ์ธ ๊ตฌ์กฐ๋ฅผ ๋ณด์ฌ์ฃผ๋ ๋ค์ด์ด๊ทธ๋จ, ์ด๋ค SW๊ฐ ์ด๋ค HW์ ๋ฐฐ์น๋๋์ง๋ฅผ ๋ํ๋ ํจํค์ง ๋ค์ด์ด๊ทธ๋จ : ์์คํ
์ ํจํค์ง ๊ตฌ์กฐ๋ฅผ ๋ํ๋ด๋ ๋ค์ด์ด๊ทธ๋จ ๋ธ๋ฃฉ์ค์ ๋ฒ์น : “๋ฆ์ด์ง ํ๋ก์ ํธ์ ์ธ๋ ฅ์ ์ถ๊ฐํ๋ฉด ์คํ๋ ค ๋ ๋ฆ์ด์ง๋ค"๋ ๋ฒ์น ํ์ดํธ๋ฐ์ค ํ
์คํธ ๊ฒ์ฆ ๊ธฐ์ค ๋ฌธ์ฅ(Statement) ์ปค๋ฒ๋ฆฌ์ง : ํ๋ก๊ทธ๋จ์ ๋ชจ๋ ๋ฌธ์ฅ์ด ์ต์ํ ํ ๋ฒ์ ์คํ๋๋๋ก ํ๋ ๊ธฐ์ค ๋ถ๊ธฐ(Branch) ์ปค๋ฒ๋ฆฌ์ง : ๊ฐ ๊ฒฐ์ ๋ฌธ์ด ์ฐธ, ๊ฑฐ์ง์ ํ ์ด์ ๊ฐ๋๋ก ์กฐํฉํ๋ ์ปค๋ฒ๋ฆฌ์ง ์กฐ๊ฑด(Condition) ์ปค๋ฒ๋ฆฌ์ง : ๊ฒฐ์ ๋ฌธ ๋ด์ ๊ฐ ์กฐ๊ฑด์ด ์ฐธ, ๊ฑฐ์ง์ ํ ์ด์ ๊ฐ๋๋ก ์กฐํฉํ๋ ์ปค๋ฒ๋ฆฌ์ง ๊ฒฐ์ (Decision) ์ปค๋ฒ๋ฆฌ์ง : ๊ฐ ์ ์ฒด ์กฐ๊ฑด์์ ์ฐธ, ๊ฑฐ์ง์ ํ ์ด์ ๊ฐ๋๋ก ์กฐํฉํ๋ ์ปค๋ฒ๋ฆฌ์ง ์์ธ ๊ฒฐ๊ณผ ๊ทธ๋ํ : ํ๋ก๊ทธ๋จ์ ์
๋ ฅ๊ณผ ์ถ๋ ฅ ๊ฐ์ ๊ด๊ณ๋ฅผ ๊ทธ๋ํ๋ก ๋ํ๋ด์ด ํ
์คํธ ์ผ์ด์ค๋ฅผ ๋์ถํ๋ ๊ธฐ๋ฒ ์ํ/๋ฒ ํ ํ
์คํธ : ์ํ-๊ฐ๋ฐ์์ ํจ๊ป ์ํ, ๋ฒ ํ-๊ฐ๋ฐ์ ์์ด ์ํ ๋คํธ์ํฌ ๊ด๋ จ ๊ฐ๋
Hub & Spoke : EAI ๊ตฌ์ถ ์ ํ; ๋จ์ผํ ์ ์ ์ ํ๋ธ ์์คํ
์ ํตํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ๋ ์ค์ ์ง์ค์ ๋ฐฉ์ MQTT : IoT ์ฅ์น ๊ฐ ํต์ ์ ์ฌ์ฉ๋๋ ๊ฒฝ๋ ๋ฉ์์ง ํ๋กํ ์ฝ CoAP : M2M ๋
ธ๋๋ค ์ฌ์ด์์ ์ด๋ฒคํธ์ ๋ํ ์ก์์ ์ ๋น๋๊ธฐ์ ์ผ๋ก ์ ์กํ๋ REST ๊ธฐ๋ฐ์ ํ๋กํ ์ฝ ๊ฑฐ๋ฆฌ ๋ฒกํฐ ์๊ณ ๋ฆฌ์ฆ : ๋คํธ์ํฌ ๋ผ์ฐํ
ํ๋กํ ์ฝ์ ํ ์ข
๋ฅ; ๊ฐ ๋
ธ๋๊ฐ ์์ ์ ๊ฑฐ๋ฆฌ์ ์ด์ ๋
ธ๋์ ๊ฑฐ๋ฆฌ ์ ๋ณด๋ฅผ ๊ตํํ์ฌ ์ต์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ ๋งํฌ ์ํ ์๊ณ ๋ฆฌ์ฆ : ๋คํธ์ํฌ ๋ผ์ฐํ
ํ๋กํ ์ฝ์ ํ ์ข
๋ฅ; ๊ฐ ๋
ธ๋๊ฐ ์ ์ฒด ๋คํธ์ํฌ์ ์ํ ์ ๋ณด๋ฅผ ์์งํ์ฌ ์ต์ ๊ฒฝ๋ก๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ ํ์ ์ ์ด : ๋ ๊ฐ์ ์คํ
์ด์
์ด ๋์์ ์ ํธ๋ฅผ ์ ์กํ๋ ๊ฒฝ์ฐ ์ถฉ๋์ด ๋ฐ์ํ์ง ์๋๋ก ์ ์ดํ๋ ๊ธฐ์ Slowris : ๋ค๋์ HTTP ์ฐ๊ฒฐ์ ๋์์ ์ด๊ณ ์ ์งํ๋ DoS RUDY : ๋๋ฆฐ ์๋๋ก ์์ ๋ฐ์ดํฐ๋ฅผ ์ ์ถํ์ฌ ์ฐ๊ฒฐ ์ํ๋ฅผ ์ ์งํ๋ ๊ฒ์ ๋ชฉํ๋ก ํ๋ DoS Slow Http read Dos : HTTP ์์ฒญ ํจํท์ ํค๋๋ฅผ ๋ณ์กฐํ์ฌ ์น ์๋ฒ์ ๋ณด๋ด ์ฐ๊ฒฐ ์ํ๋ฅผ ์ ์งํ๊ฒ ํ๋ DoS SNMP(Simplified Network Management Protocol) : ๋คํธ์ํฌ ์ฅ๋น์ ์ํ๋ฅผ ๋ชจ๋ํฐ๋งํ๊ณ ๊ด๋ฆฌํ๊ธฐ ์ํ ํ๋กํ ์ฝ DHCP(Dynamic Host Configuration Protocol) : ๋คํธ์ํฌ ์ฅ์น์ IP ์ฃผ์๋ฅผ ์๋์ผ๋ก ํ ๋นํ๋ ํ๋กํ ์ฝ RARP (Reverse Address Resolution Protocol) : MAC ์ฃผ์ -> IP ์ฃผ์ ๋ณํ ํ๋กํ ์ฝ Ad-hoc ๋คํธ์ํฌ : ์ค์ ๋ผ์ฐํฐ๋ ์ก์ธ์ค ์ง์ ์์ด ์๋ก ์ง์ ํต์ ํ ์ ์๋๋ก ํ๋ ์์ ๋ถ์ฐ ๋ฌด์ ๋คํธ์ํฌ ํจํท ๊ตํ ๋ฐฉ์ ๊ฐ์ํ์ ๋ฐฉ์ : ๋ชฉ์ ์ง ํธ์คํธ์ ๋ฏธ๋ฆฌ ์ฐ๊ฒฐ ํ ํต์ ํ๋ ์ฐ๊ฒฐํ ๊ตํ ๋ฐฉ์ ๋ฐ์ดํฐ๊ทธ๋จ ๋ฐฉ์ : ํค๋๋ฅผ ๋ถ์ฌ์ ๊ฐ๋ณ์ ์ผ๋ก ์ ๋ฌํ๋ ๋น์ฐ๊ฒฐํ ๊ตํ ๋ฐฉ์ L2TP (Layer 2 Tunneling Protocol) : VPN ํ๋กํ ์ฝ์ ์ผ์ข
์ผ๋ก, PPP ํ๋กํ ์ฝ์ ์ฌ์ฉํ์ฌ ๋ฐ์ดํฐ๋ฅผ ์บก์ํํ๊ณ ์ ์กํ๋ ๋ฐฉ์ ์ค๋ฅ ์ ์ด ๋ฐฉ์ FEC (Forward Error Correction) : ์ค๋ฅ ๊ฒ์ถ, ์ค์ค๋ก ์์ ํ๋ ๋ฐฉ์ Hamming Code BEC (Backward Error Correction) : ์ค๋ฅ ๊ฒ์ถ, ์ฌ์ ์ก ์์ฒญํ๋ ๋ฐฉ์ Parity ๊ฒ์ฌ CRC (Cyclic Redundancy Check) : ๋ฐ์ดํฐ ๋ธ๋ก์ ๋ํ ๋คํญ์ ๋๋์
์ ์ฌ์ฉํ์ฌ ์์ฑ๋ ์ฒดํฌ์ฌ์ ์ด์ฉ ๋ณด์ ๊ด๋ จ ๊ฐ๋
kill switch : ์ค๋งํธํฐ ์ด์ฉ์๊ฐ ๋๋๋นํ ์ค๋งํธํฐ์ ์๋์, ์น์ฌ์ดํธ๋ฅผ ํตํด ์ ์งํ ์ ์๋๋ก ํ๋ ์ผ์ข
์ ์ํญ ๊ธฐ๋ฅ ์ ๋ก ๋ฐ์ด ๊ณต๊ฒฉ : ๋ณด์ ์ทจ์ฝ์ ์ด ์๋ ค์ง๊ธฐ ์ ์ ํด๋น ์ทจ์ฝ์ ์ ์
์ฉํ์ฌ ์ด๋ฃจ์ด์ง๋ ๊ณต๊ฒฉ ARP Spoofing : ARP ํ๋กํ ์ฝ์ ์ด์ฉํ์ฌ ๋คํธ์ํฌ ์์ ๋ค๋ฅธ ํธ์คํธ์ MAC ์ฃผ์๋ฅผ ์์กฐํ๋ ๊ณต๊ฒฉ ๊ธฐ๋ฒ ๋์งํธ ํฌ๋ ์ : ๋์งํธ ๊ธฐ๊ธฐ์์ ๋ฐ์ํ ๋ฒ์ฃ๋ ์ฌ๊ณ ์ ์ฆ๊ฑฐ๋ฅผ ์์ง, ๋ถ์, ๋ณด์กดํ๋ ๊ณผ์ ๋ฃจํธํท : ์์คํ
์ ๋ชฐ๋ ์ค์น๋์ด ์ฌ์ฉ์์ ๊ถํ์ ํ์ทจํ๊ฑฐ๋ ์์คํ
์ ์ ์ดํ๋ ์
์ฑ ์ํํธ์จ์ด ์คํผ์ด ํผ์ฑ : ํน์ ๊ฐ์ธ์ด๋ ์กฐ์ง์ ๋์์ผ๋ก ํ๋ ๋ง์ถคํ ํผ์ฑ ๊ณต๊ฒฉ APT ๊ณต๊ฒฉ : ํน์ ํ๊น์ ๋ชฉํ๋ก ๋ค์ํ ์๋จ์ ํตํ ์ง์์ ์ด๊ณ ์ง๋ฅ์ ์ธ ๋ง์ถคํ ๊ณต๊ฒฉ ๊ธฐ๋ฒ SET(Secure Electronic Transaction) : ์ ์ ์๊ฑฐ๋์์ ์์ ํ ๊ฒฐ์ ๋ฅผ ์ํ ํ๋กํ ์ฝ ์ฌ์ด๋ฒ ํฌ์ฒด์ธ : ๋กํ๋ ๋งํด์ ๊ณต๊ฒฉํ ๋ฐฉ์ ์์คํ
DAC (Discretionary Access Control) : ์ฌ์ฉ์๊ฐ ์์ ๋กญ๊ฒ ๊ฐ์ฒด์ ๋ํ ์ ๊ทผ ๊ถํ์ ๊ด๋ฆฌํ ์ ์๋ ๋ฐฉ์ MAC (Mandatory Access Control) : ์์คํ
๊ด๋ฆฌ์๊ฐ ์ ์ฑ
์ ๋ฐ๋ผ ์ฌ์ฉ์์๊ฒ ์ ๊ทผ ๊ถํ์ ๋ถ์ฌํ๋ ๋ฐฉ์ 3A (AAA) : ์ ๋ณด ๋ณด์์ ํต์ฌ์์ Authentication Authorization Accounting ISMS (Information Security Management System) : ์ ๋ณด ๋ณดํธ๋ฅผ ์ํ ๊ด๋ฆฌ ์ฒด๊ณ ์ฌํ๊ณตํ ๊ธฐ๋ฒ : ์ธ๊ฐ์ ์ฌ๋ฆฌ์ ํ๋์์์ ์ด์ฉํ์ฌ ์ ๋ณด๋ฅผ ํ์ทจํ๊ฑฐ๋ ์์คํ
์ ์นจ์
ํ๋ ๊ธฐ๋ฒ SIEM : ๋ณด์ ์ ๋ณด ๋ฐ ์ด๋ฒคํธ ๊ด๋ฆฌ ์์คํ
; ๋ณด์ ๋ก๊ทธ์ ์ด๋ฒคํธ๋ฅผ ์์ง, ๋ถ์ํ์ฌ ์ค์๊ฐ์ผ๋ก ๋ณด์ ์ํ์ ํ์งํ๊ณ ๋์ํ๋ ์์คํ
์ VS ๋ฐ์ด๋ฌ์ค ์ : ์ค์ค๋ก ๋ณต์ ํ์ฌ ๋คํธ์ํฌ๋ฅผ ํตํด ์ ํ๋๋ ์
์ฑ ์ฝ๋; ํธ์คํธ ํ์ผ์ ๊ฐ์ผ์ํค์ง ์์ ๋ฐ์ด๋ฌ์ค : ํธ์คํธ ํ์ผ์ ์ฝ์
๋์ด ์คํ๋ ๋๋ง ํ์ฑํ๋๋ ์
์ฑ ์ฝ๋; ํธ์คํธ ํ์ผ์ ๊ฐ์ผ์ํด ๋์นญํค, ๋น๋์นญํค(๊ณต๊ฐํค) ๋์นญํค : AES, DES, ARIA SEED ๋น๋์นญํค : RSA, ECC ATM(Asynchronous Transfer Mode) : ๊ณ ์ ๋ฐ์ดํฐ ์ ์ก์ ์ํ ์
๊ธฐ๋ฐ์ ํจํท ๊ตํ ๋ฐฉ์; 53๋ฐ์ดํธ์ ๊ณ ์ ๊ธธ์ด ์
์ ์ฌ์ฉ ์ค๋จธํ(Smurfing) : ICMP ํจํท์ ์ด์ฉํ์ฌ ๋๋์ ํธ๋ํฝ์ ๋ฐ์์ํค๋ DoS ๊ณต๊ฒฉ ๊ธฐ๋ฒ; ๊ณต๊ฒฉ์๊ฐ ๋ธ๋ก๋์บ์คํธ ์ฃผ์๋ก ICMP Echo ์์ฒญ์ ๋ณด๋ด๊ณ , ์๋ต์ ํ๊ฒ์๊ฒ ์ ์กํ๊ฒ ํจ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ด๋ จ ๊ฐ๋
๋๊ด์ ๊ฒ์ฆ : ํธ๋์ญ์
์ ์ผ๋จ ์ํํ๊ณ , ํธ๋์ญ์
์ข
๋ฃ ์ ๊ฒ์ฆ์ ์ํํ์ฌ ๋ฐ์ดํฐ๋ฒ ์ด์ค ๋ฐ์ํ๋ ๊ธฐ๋ฒ 2PC (Two-Phase Commit) : ๋ถ์ฐ ๋ฐ์ดํฐ๋ฒ ์ด์ค ์์คํ
์์ ํธ๋์ญ์
์ ์์์ฑ์ ๋ณด์ฅํ๊ธฐ ์ํด ๋ ๋จ๊ณ๋ก ์ปค๋ฐ์ ์ํํ๋ ๋ฐฉ์ ์์ ํจ์ ์ข
์(Full) : ๋ฆด๋ ์ด์
์ ๋ชจ๋ ์์ฑ์ด ๊ธฐ๋ณธํค์๋ง ์ข
์๋๋ ์ํ ๋ถ๋ถ ํจ์ ์ข
์(Partial) : ๋ฆด๋ ์ด์
์ ์ผ๋ถ ์์ฑ์ด ๊ธฐ๋ณธํค์๋ง ์ข
์๋๋ ์ํ ์ดํ ํจ์ ์ข
์(Transient) : A->B, B->C ์ด๋ฉด A->C๊ฐ ์ฑ๋ฆฝํ๋ ์ํ ์ฒดํฌํฌ์ธํธ ํ๋ณต ๊ธฐ๋ฒ : ์ฅ์ ๋ฐ์ ์ ๊ฒ์ฌ์ ์ดํ์ ์ฒ๋ฆฌ๋ ํธ๋์ญ์
์ ๋ํด์๋ง ์ฅ์ ๋ฅผ ๋ณต๊ตฌํ๋ ๊ธฐ๋ฒ ๋กํน : ๋ค์ค ํธ๋์ญ์
ํ๊ฒฝ์์ ํธ๋ ์ญ์
์ ์์ฐจ์ ์งํ์ ๋ณด์ฅํ๋ ์ง๋ ฌํ ๊ธฐ๋ฒ LIKE ๋ฌธ๋ฒ % : 0๊ฐ ์ด์์ ๋ฌธ์์ด๊ณผ ์ผ์น [ ] : 1๊ฐ์ ๋ฌธ์์ ์ผ์น [^ ] : 1๊ฐ์ ๋ฌธ์์ ๋ถ์ผ์น _ : ํน์ ์์น์ 1๊ฐ ๋ฌธ์์ ์ผ์น ๊ด๊ณ ํด์ : ๋น์ ์ฐจ์ ์ธ์ด; ๊ด๊ณ ๋ฐ์ดํฐ๋ฒ ์ด์ค์์ ๋ฐ์ดํฐ๋ฅผ ์ง์ํ๊ธฐ ์ํ ์ํ์ ํํ ๋ฐฉ๋ฒ ALL : ์ฃผ๋ก ์๋ธ์ฟผ๋ฆฌ์์ ์ฌ์ฉํ๋ ๋ค์คํ ์ฐ์ฐ์; ๋ชจ๋ ํ์ด ์กฐ๊ฑด์ ๋ง์กฑํด์ผ ํจ ANY : ์ฃผ๋ก ์๋ธ์ฟผ๋ฆฌ์์ ์ฌ์ฉํ๋ ๋ค์คํ ์ฐ์ฐ์; ํ๋ ์ด์์ ํ์ด ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ์ฐธ ๊ด๊ณ๋์ ๊ธฐํธ: $\cup$(ํฉ์งํฉ), $-$(์ฐจ์งํฉ), $\times$(์นดํฐ์
๊ณฑ), $\pi$(ํ๋ก์ ํธ), $\bowtie$(์กฐ์ธ), $\sigma$(์ ํ), $\div$(๋๋์
) ์กฐ์ธ ๋ฐฉ์ Theta Join : ์กฐ์ธ ์กฐ๊ฑด์ด ๋ฑํธ๊ฐ ์๋ ๋ค๋ฅธ ๋น๊ต ์ฐ์ฐ์๋ฅผ ์ฌ์ฉํ๋ ์กฐ์ธ ๋ฐฉ์ Equi Join : ์กฐ์ธ ์กฐ๊ฑด์ด ๋ฑํธ(=)์ธ ์กฐ์ธ ๋ฐฉ์ Natural Join : ๋ ๋ฆด๋ ์ด์
์ ๊ณตํต ์์ฑ์ ๊ธฐ์ค์ผ๋ก ์๋์ผ๋ก ์กฐ์ธํ๋ ๋ฐฉ์ ์ธ์
ํ์ด์ฌํน (Session Hijacking) : ์ฌ์ฉ์์ ์ธ์
์ ํ์ทจํ์ฌ ๋ถ๋ฒ์ ์ผ๋ก ์ ๊ทผํ๋ ๊ณต๊ฒฉ ๊ธฐ๋ฒ OS ๊ด๋ จ ๊ฐ๋
๋ง์ดํฌ๋ก์ปค๋ : ๋ค์ํ ์๋น์ค๋ฅผ Kernel Mode๊ฐ ์๋ User Mode์์ ์ฒ๋ฆฌํ๋ ์ด์ํ ์ปค๋ ํ๋ก์ธ์ค ์ค์ผ์ฅด๋ง SJF(Shortest Job First) : ๊ฐ์ฅ ์งง์ ์์
์ ๋จผ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ์ HRN (Highest Response Ratio Next) : ๋๊ธฐ ์๊ฐ๊ณผ ์๋น์ค ์๊ฐ์ ๊ณ ๋ คํ์ฌ ์ฐ์ ์์๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐฉ์ RR(Round Robin) : ๊ฐ ํ๋ก์ธ์ค์ ๋์ผํ ์๊ฐ ํ ๋น๋์ ์ฃผ๊ณ ์ํ์ ์ผ๋ก ์ฒ๋ฆฌํ๋ ๋ฐฉ์ SRTF(Shortest Remaining Time First) : ๋จ์ ์คํ ์๊ฐ์ด ๊ฐ์ฅ ์งง์ ํ๋ก์ธ์ค๋ฅผ ๋จผ์ ์ฒ๋ฆฌํ๋ ๋ฐฉ์ ํผํฐ์จ ์๊ณ ๋ฆฌ์ฆ : ๋ ํ๋ก์ธ์ค ๊ฐ์ ์ํธ ๋ฐฐ์ ๋ฅผ ๋ณด์ฅํ๋ ์๊ณ ๋ฆฌ์ฆ; ํ๋๊ทธ์ ํด์ ์ฌ์ฉํ์ฌ ์ํธ ๋ฐฐ์ ์ ์ง์
ํ์ฉ์ ๊ตฌํ ๊ธฐํ ๊ฐ๋
ํผ์ฝ๋ท : ์ฌ๋ฌ ๊ฐ์ ๋
๋ฆฝ๋ ์ฅ์น๊ฐ ๋ธ๋ฃจํฌ์ค ๊ธฐ์ ์ด๋ UWB ํต์ ๊ธฐ์ ์ ์ฌ์ฉํ์ฌ ํต์ ๋ง์ ํ์ฑํ๋ ๋ฌด์ ๋คํธ์ํฌ ๊ธฐ์ ์ง๊ทธ๋น :์ ์ ์ ์ก ์๋๋ฅผ ๊ฐ๋ ํ์คํ ๋ฉ์ด์
๋ฐ ๋ฐ์ดํฐ ๋คํธ์ํฌ๋ฅผ ์ํ ํ์ค ๊ธฐ์ ํด๋ฆฌ์ด๋ง ํ์ฐ์ค : ๋์งํธ ์ ์๊ถ ๋ผ์ด์ ์ฑ์ ์ค๊ฐํ๊ณ ๋ผ์ด์ ์ค ๋ฐ๊ธ์ ์ํํ๋ ์ ์ฐ์ ๋ฐ์ดํฐ ๋งํธ : ๋ฐ์ดํฐ์ ํ ๋ถ๋ถ์ผ๋ก์ ํน์ ์ฌ์ฉ์๊ฐ ๊ด์ฌ์ ๊ฐ๋ ๋ฐ์ดํฐ๋ค์ ๋ด์ ๋น๊ต์ ์์ ๊ท๋ชจ์ ๋ฐ์ดํฐ ์จ์ดํ์ฐ์ค OLAP : ์จ๋ผ์ธ ๋ถ์ ์ฒ๋ฆฌ; ๋ฐ์ดํฐ ์จ์ดํ์ฐ์ค์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ต์ ์ธ ์ ๋ณด๋ก ๋ณํ์์ผ์ ์์ฌ๊ฒฐ์ ์ ์ง์ํ๋ ์ญํ ์ํ semantic web : ์น ์์ ์ ๋ณด์ ์๋ฏธ๋ฅผ ๋ถ์ฌํ์ฌ ๊ธฐ๊ณ๊ฐ ์ดํดํ ์ ์๋๋ก ํ๋ ๊ธฐ์ ์จํจ๋ก์ง(Ontology) : ํน์ ๋๋ฉ์ธ์ ๋ํ ๊ฐ๋
๊ณผ ๊ทธ๋ค ๊ฐ์ ๊ด๊ณ๋ฅผ ์ ์ํ๋ ๋ช
์ธ ๋์งํธ ์์นด์ด๋น : ๋์งํธ ์๋ฃ๋ฅผ ์ฅ๊ธฐ์ ์ผ๋ก ๋ณด์กดํ๊ณ ๊ด๋ฆฌํ๋ ๊ณผ์ CEP(Complex Event Processing) : ์ค์๊ฐ์ผ๋ก ๋๋์ ์ด๋ฒคํธ๋ฅผ ์ฒ๋ฆฌํ๊ณ ๋ถ์ํ๋ ๊ธฐ์ ๋
ธ๋ชจํฌ๋น์ : ์ค๋งํธํฐ์ ์์ด๋ฒ๋ฆฌ๊ฑฐ๋ ์ฌ์ฉํ ์ ์๋ ์ํฉ์ ๋ํ ๋ถ์๊ฐ ITIL(Information Technology Infrastructure Library) : ์๊ตญ ์ ๋ถ๊ฐ ๋ค์ํ IT ์๋น์ค๋ค์ ๊ด๋ฆฌ ๋ฐฉ๋ฒ๋ค์ ๋ชจ์ ๋ง๋ ํ์ค์ ์ธ ์ฐธ๊ณ ๋ฌธ์ ๋ฐ์ดํฐ ๋ง์ด๋ : ๋๋์ ๋ฐ์ดํฐ์์ ์ ์ฉํ ์ ๋ณด๋ฅผ ์ถ์ถํ๋ ๊ณผ์ ์คํ ์คํ : ์ํ์น ๋ผ์ด์ ์ค๋ก ๋ฐฐํฌ๋๋ ํด๋ผ์ฐ๋ ํ๋ซํผ ํ๋ก์ ํธ BCP(Business Continuity Planning) : ์ฌํด ๋ฐ์ ์ ๋น์ฆ๋์ค ์ด์์ ์ง์ํ๊ธฐ ์ํ ๊ณํ Trust Zone : ARM์์ ๊ฐ๋ฐํ ๋ณด์ ๊ธฐ์ ๋ก, ํ๋์จ์ด ๊ธฐ๋ฐ์ ๋ณด์ ์์ญ์ ์ ๊ณตํ์ฌ ๋ฏผ๊ฐํ ๋ฐ์ดํฐ๋ฅผ ๋ณดํธํ๋ ๊ธฐ์ WSDL (Web Services Description Language) : ์น ์๋น์ค์ ๊ธฐ๋ฅ์ ๊ธฐ์ ํ๋ XML ๊ธฐ๋ฐ์ ์ธ์ด EAI : ๊ธฐ์
๋ด ๋ค์ํ ์์คํ
๊ฐ์ ๋ฐ์ดํฐ ํตํฉ ๋ฐ ์ํธ ์ด์ฉ์ฑ์ ์ํ ์๋ฃจ์
NUI (Natural User Interface) : ์ ์ฒด๋ฅผ ํ์ฉํ ์ฌ์ฉ์ ์ธํฐํ์ด์ค ์ํธํ ์๊ณ ๋ฆฌ์ฆ : AES, DES, RSA, IDEA, Skipjack CVS : Concurrent Versions System; ๋ถ์ฐ ๋ฒ์ ๊ด๋ฆฌ ์์คํ
; ์ค์ ์ง์ค์ ๋ฒ์ ๊ด๋ฆฌ ์์คํ
SVN : Subversion; ๋ฒ์ ๊ด๋ฆฌ ์์คํ
์ ์ผ์ข
; CVS์ ๋จ์ ์ ๋ณด์ํ๊ธฐ ์ํด ๊ฐ๋ฐ๋จ ๊ฐ์ ์ปดํจํฐ์ ์ธ๊ฐ์ด ์ํตํ๋ ๋ฐฉ๋ฒ ์ด์
๋ธ๋ฆฌ์ด ์ด์
๋ธ๋ฆฌ์ด์ ๋ฒ์ญ๊ธฐ๋ ์ด์
๋ธ๋ฌ(Assembler)๋ผ๊ณ ํ๋ค cpu์นฉ์
์ด ๋ฐ๋๋๋ง๋ค ์ด์
๋ธ๋ฆฌ์ด๊ฐ ๋ฐ๋๋ค ๊ณ ๊ธ์ธ์ด ๊ณ ๊ธ์ธ์ด์ ๋ฒ์ญ๊ธฐ๋ ์ปดํ์ผ๋ฌ(Compiler)๋ผ๊ณ ํ๋ค ์ปดํ์ผ๋ฌ์ ์ ํํ ์ ์ ์ด๋ค ์ธ์ด๋ก ์ฐ์ฌ์ง ํ๋ก๊ทธ๋จ์ ๊ฐ์ ์ญํ ์ ๋ค๋ฅธ ์ธ์ด๋ก ๋ฐ๊ฟ์ฃผ๋ ํ๋ก๊ทธ๋จ
1952๋
๊ทธ๋ ์ด์ค ํธํผ(Grace Hopper)๊ฐ UNIVAC์ฉ ํ๋ก๊ทธ๋๋ฐ์ธ์ด A-0 ์ปดํ์ผ๋ฌ๋ฅผ ์ ์ ์ปดํ์ผ๋ฌ vs ์ธํฐํ๋ฆฌํฐ ํ๋ก๊ทธ๋จ ์ฒ๋ฆฌ๊ณผ์ ์ปดํ์ผ๋ฌ์ ์ฒ๋ฆฌ ๊ณผ์ Lexical analysis (์ดํ ๋ถ์) token์ ์์ฑํ๋์ผ, token์ ์ดํ์ ์ต์ ๋จ์ Syntax analysis (๊ตฌ๋ฌธ ๋ถ์) token์ ์ฝ์ด์ ์ค๋ฅ๋ฅผ ๊ฒ์, ๊ตฌ๋ฌธ ๊ตฌ์กฐ๋ฅผ ๋ง๋ ๋ค (์ฃผ๋ก ํธ๋ฆฌํํ) Semantic analysis (์๋ฏธ ๋ถ์) type checking Intermediate code generation (์ค๊ฐ ์ฝ๋ ์์ฑ) ์ค๊ฐ ์ฝ๋๋ก ๋ณํ Code optimization (์ฝ๋ ์ต์ ํ) ์ค๊ฐ ์ฝ๋๋ฅผ ๋ ํจ์จ์ ์ผ๋ก ๋ณํ Code generation (์ฝ๋ ์์ฑ) ๋ชฉ์ ์ฝ๋ ์์ฑ Lexical analysis (์ดํ ๋ถ์) token : ๋ฌธ๋ฒ์ ์ผ๋ก ์๋ฏธ์๋ ์ต์ ๋จ์ FSA (Finite State Automata, ์ ํ ์ํ ์คํ ๋งํ) token์ ์ธ์ํ๋ ๋ฐฉ๋ฒ ์์ ์ํ ํ ๊ฐ์ ๋ ์ํ ์ฌ๋ฌ ๊ฐ๋ฅผ ๊ฐ์ง DFA (Deterministic Finite Automata) FSA์ ํ ์ข
๋ฅ ๊ฐ ์ํ์์ ๋ป์ด๋๊ฐ๋ edge๊ฐ ํ๋์ฉ๋ง ์กด์ฌ ฮต๊ฐ ๋ถ์ edge ์์ ๋ถ์ํ ํ ํฐ์ ํํํ๋ ๋ฐฉ๋ฒ Lexeme = <ํ ํฐ๋ฒํธ, ํ ํฐ ๊ฐ>
์์ if X < Y … (29, 0) (1, X) (18, 0) (1, Y) … ์๋ณ์์ ํ ํฐ๋ฒํธ๋ 1๋ฒ, ์์๋ 2๋ฒ ๋ฑ์ผ๋ก ๊ณ ์ Syntax analysis (๊ตฌ๋ฌธ ๋ถ์) token์ ์ฝ์ด์ ์ค๋ฅ๋ฅผ ๊ฒ์, parse tree๋ฅผ ๋ง๋ ๋ค CFG (Context Free Grammer) ๊ตฌ๋ฌธ์ ํํํ๋ ๋ฐฉ๋ฒ G = (N, T, P, S) N = nonterminal symbol ์ํ๋ฒณ ๋๋ฌธ์๋ก ํํ T = terminal symbol (token) ์ํ๋ฒณ ์๋ฌธ์+์ซ์, ์ฐ์ฐ์, ๊ตฌ๋ถ์, ํค์๋ ๋ฑ P = production rule ์) S -> T+T, T -> ‘0’|‘1’|‘2’ S = start symbol L(G) : ์ด ๋ฌธ๋ฒ์ผ๋ก ์์ฑ๋๋ ์ธ์ด ์ฌ๋ฌ๊ฐ์ง CFG ํํ๋ฒ BNF (Backus-Naur Form) EBNF (Extended BNF) ์ ๋ (derivation) ์์ฑ ๊ท์น๋ฅผ ์ ์ฉํ์ฌ ๋ฌธ์ฅ์ ์์ฑํ๋ ๊ณผ์ ์ ๋๋ฅผ ํ๋ ๊ณผ์ ์์ ํ๋์ฉ ๊ณจ๋ผ์ ๋ฐ๊ฟ ์ ๋ ํธ๋ฆฌ : ์ ๋ ๊ฒฝ๋ก๋ฅผ ์ถ์ํ ์์ผ ํํํ ๊ฒ ์ข์ธก ์ ๋(leftmost derivation) ๊ฐ์ฅ ์ผ์ชฝ์ ์๋ nonterminal์ ๋จผ์ ๋์น ์ฐ์ธก ์ ๋(rightmost derivation) ๊ฐ์ฅ ์ค๋ฅธ์ชฝ์ ์๋ nonterminal์ ๋จผ์ ๋์น ๋ชจํธ์ฑ (ambiguity) ๋ฌธ๋ฒ G์ ์ํด ์์ฑ๋๋ ์ด๋ค ๋ฌธ์ฅ์ด ๋๊ฐ ์ด์์ ์ ๋ํธ๋ฆฌ๋ฅผ ๊ฐ๋๋ค๋ฉด ๋ฌธ๋ฒ G๋ ๋ชจํธํ๋ค๊ณ ํ๋ค ๋ชจํธํ์ง ์์ ๋ฌธ๋ฒ์ ์ข์ธก ์ ๋์ ์ฐ์ธก ์ ๋๊ฐ ๊ฐ๋ค ๋ชจํธ์ฑ ํด๊ฒฐ ์ฐ์ฐ์ ์ฐ์ ์์ ๋์
๊ฒฐํฉ ๋ฒ์น ๋์
Left Recursion์ ์ข์ธก ๊ฒฐํฉ์ ์ฌ์ฉ ex) A -> A+a | a Right Recursion์ ์ฐ์ธก ๊ฒฐํฉ์ ์ฌ์ฉ ex) A -> a+A | a ๊ตฌ๋ฌธ ๋ถ์์ 2๊ฐ์ง ๋ฐฉ์ top-down, bottom-up Top-down parsing Top-down ๋ฐฉ์ ์ข์ธก ์ ๋์ ๊ฐ์ ์์ ์ ์์ฑ ๊ท์น ์ ์ฉ backtracking : ์ ๋๋ ๋ฌธ์์ด๊ณผ ์
๋ ฅ ๋ฌธ์์ด์ด ๊ฐ์ง ์์ผ๋ฉด ๋ค๋ฅธ ์์ฑ๊ท์น ์ ์ฉ Bottom-up ๋ฐฉ์ ์ฐ์ธก ์ ๋์ ์ญ์์ ์์ฑ ๊ท์น ์ ์ฉ LL ํ์ฑ ์ผ์ชฝ->์ค๋ฅธ์ชฝ์ผ๋ก ์ฝ์ด์ ์ขํ์ค ์์ฑ backtracking X, ๋น ๋ฅด๋ค ๊ฒฐ์ ์ ์ผ๋ก ํ์ฑ ์ฌ์ฉ๋ ์ ์ ฮต-์์ฑ๊ท์น
Nonterminal A๊ฐ ฮต๋ฅผ ์ ๋ํ ์ ์์ผ๋ฉด A๋ฅผ nullableํ๋ค๊ณ ๋ถ๋ฅธ๋ค lhs, rhs
A->XXX์์ lhs๋ A, rhs๋ XXX โ (Ring Sum)
A์ ฮต๊ฐ ์์ผ๋ฉด, AโB = (A์์ ฮต๋นผ๊ณ A ํฉ์งํฉ B) A์ ฮต๊ฐ ์์ผ๋ฉด, AโB = A First nonterminal A๋ก ๋ถํฐ ์ ๋๋์ด ์ฒซ๋ฒ์งธ๋ก ๋ํ๋ ์ ์๋ terminal์ ์งํฉ X->Y1Y2Y3์ผ๋, FIRST(X) = FIRST(X) U FIRST(Y1) โ FIRST(Y2) โ FIRST(Y3)
Follow A ๋ค์์ ๋์ค๋ terminal์ ์งํฉ A->ฮฑBฮฒ, ฮฒ != ฮต ์ผ๋, FOLLOW(B) = FOLLOW(B) U (FIRST(ฮฒ)-{ฮต})
A->ฮฑB ๋๋ A->ฮฑBฮฒ, FIRST(ฮฒ)์ ฮต๊ฐ ์ํ ๋, FOLLOW(B) = FOLLOW(B) U FOLLOW(A)
LL์กฐ๊ฑด FIRST(ฮฑ)์ FIRST(ฮฒ)๊ฐ ๊ฒน์น๋ฉด ์๋๋ค FIRST(ฮฑ)์ ฮต๊ฐ ์์ผ๋ฉด, FOLLOW(ฮฑ)์ FIRST(ฮฒ)๊ฐ ๊ฒน์น๋ฉด ์๋๋ค LL ์กฐ๊ฑด์ ๋ง์กฑํ๋ ๋ฌธ๋ฒ = LL ํ์ฑ ๋๋ ๋ฌธ๋ฒ LL(1) ๋ฌธ๋ฒ ์์์ ๋ฌธ๋ฒ์ ๋ํ์ฌ LL ์กฐ๊ฑด์ ๋ง์กฑํ๋ CFG 1 : LOOKAHEAD๊ฐ 1๊ฐ๋ผ๋ ์๋ฏธ ๋ค์๊ณผ ๊ฐ์ ๊ฒฝ์ฐ LL(1)๋ฌธ๋ฒ์ด ๋์ง ์๋๋ค ๋ชจํธํ ๋ฌธ๋ฒ ์ฐ์ ์์ ์ฃผ๊ธฐ, ๊ฒฐํฉ๋ฒ์น ๋ฐ์์ผ๋ก ํด๊ฒฐ left-factoring์ด ๋๋ ๊ฒฝ์ฐ ๊ณตํต ์๋ถ๋ถ์ ์๋ก์ด nonterminal๋ก ๋ง๋ค์ด ํด๊ฒฐ left-recursiveํ ๊ฒฝ์ฐ ์ง์ recursion : A -> Aฮต ์ธ๊ฒฝ์ฐ ๊ฐ์ recursion : A -> B, B -> A ์ธ๊ฒฝ์ฐ LOOKAHEAD ์ด๋ค ๊ท์น์ด ์ ์ฉ๋์์๋ ๋งจ ์ฒ์ ๋์ฌ ์ ์๋ terminal ์งํฉ A->X1X2X3์ผ๋, LOOKAHEAD(A) = FIRST(X1) โ FIRST(X2) … โ FOLLOW(A)
Strong LL(1) LL(1)๊ณผ ํญ์ ๋์ผ (1์ด ์๋๋๋ ๋ค๋ฆ) LOOKAHEAD(A->ฮฑ)์ LOOKAHEAD(A->ฮฒ)๊ฐ ๊ฒน์น์ง ์๋ ๋ฌธ๋ฒ LL(1) ํ์ ๊ตฌํ ๋ฐฉ๋ฒ Recursive descent parser ์ฅ์ : ์ง๊ด์ ์ฝ๋ค ๋จ์ : ์์ฑ ๊ท์น์ด ๋ฐ๋๋ฉด ๊ตฌ๋ฌธ ๋ถ์๊ธฐ๋ฅผ ๊ณ ์ณ์ผ ํ๋ค Predictive parser PDA(PushDown Automata)์ ๊ธฐ๋ฐ
์์ฑ ๊ท์น์ด ๋ฐ๋๋ฉด ํ์ฑ ํ
์ด๋ธ๋ง ์์
ํ์ฑํ
์ด๋ธ ์์ (?์๋ ๊ท์น๋ฒํธ๊ฐ ๋ค์ด๊ฐ๋ค)
a b S ? ? A ? ? ํ์ฑํ
์ด๋ธ์ ๋๊ฐ ์ด์์ ์์ฑ ๊ท์น์ด ๋ค์ด๊ฐ๋ ๊ฒฝ์ฐ -> NOT LL(1)
Stack์ ์์ Bottom-up parsing left-recursive ๋ฌธ๋ฒ๋ ํ์ฑ ๊ฐ๋ฅ LL(k) ์ข์ธก์ ๋ ๊ธฐ๋ฐ k๊ฐ์ symbol์ lookahead Top-down parsing, recursive descent parsing, predictive parsing, LL parser ํ์คํธ๋ฆฌ๋ฅผ pre-roder๋ก ์ํ ๋ฐ ์์ฑ LR(k) ์ฐ์ธก์ ๋ ๊ธฐ๋ฐ k๊ฐ์ symbol์ lookahead Bottom-up parsing, shift-reduce parsing, LR parser ํ์คํธ๋ฆฌ๋ฅผ post-order๋ก ์ํ ๋ฐ ์์ฑ Reduce S=>ฮฑฮฒฯ์ด๊ณ A->ฮฒ์ด๋ฉด ฮฒ๋ฅผ A๋ก ๋์นํ๋ ๊ฒ : S=>ฮฑAฯ ์์ symbol์ด ๋์ฌ ๋๊น์ง reduce ํ๋ค Handle S=>ฮฑฮฒฯ์ด๊ณ A->ฮฒ์ด๋ฉด ฮฒ๋ฅผ ฮฑฮฒฯ์ handle์ด๋ผ๊ณ ํ๋ค ๋ ๊ฐ ์ด์์ handle์ด ์กด์ฌํ ๋ -> ๋ชจํธํ๋ค Shift์ Reduce๋ก Parsing ํ๊ธฐ Stack์ ์์ Issue Shift์ Reduce ์ค ์ด๋ ๊ฒ์ ํ ๊น? Stack์ top์์ ์ผ๋ง๋งํผ์ handle๋ก ๋ณผ ๊ฒ์ธ๊ฐ? ํด๊ฒฐ๋ฐฉ๋ฒ: LR Parsing Table YACC LALR ํ์ ์์ฑ๊ธฐ foo.y –(yacc)–> y.tab.c –(gcc)–> a.out *.y ํ์ผ ๊ตฌ์กฐ 1<์ ์ธ๋ถ> 2... 3%% 4... 5exp : exp '+' term; 6factor : ident; 7... 8%% 9<์ฌ๋ฌ ํจ์> ๋ชจํธํ ๋ฌธ๋ฒ์ผ๋ก LR Conflict ๋ฐ์ ์ ์ ์ธ๋ถ์์ ์ฐ์ ์์ ์ง์ ํ์ฌ ํด๊ฒฐ LR Parsing Table Action table : Action + Parser ์ํ Goto table : Parser ์ํ LR(0) ํ์ฑ ํ
์ด๋ธ ๋ง๋ค๊ธฐ LR(0) ์์ดํ
rhs์ ์ (’.’) symbol์ ๊ฐ์ง ์์ฑ ๊ท์น ex) A->ฮฑ.ฮฒ, A->. closure ์ (’.’)๋ค์ non-terminal์ด ์ค๋ฉด ์ฌ๊ท์ ์ผ๋ก ์ถ๊ฐ S’ -> S, S -> (L)|id, L -> S | L,S closure({[S’->.S]}) = {[S’->.S], [S->.(L)], [S->.id]} goto goto(I, X)์ด๋ฉด ์ ์ X๋ค๋ก ์ฎ๊ธฐ๊ณ closure๋ฅผ ์ทจํ๋ค X๊ฐ ์์ผ๋ฉด ๋ฃ์ง ์๋๋ค I={[G->E=E], [E->E.+T]} ์ผ๋, goto(I, +) = closure({E->E+.T}) : ์ ์ +๋ค๋ก ์ฎ๊น C0 ์์ฑ๊ท์น S’->S์์๋ถํฐ ์ฐจ๋ก๋ก closure์ goto๋ฅผ ์ ์ฉํ์ฌ ์ป์ ๋ชจ๋ ํ๋นํ LR(0)์ ์์ดํ
์งํฉ๋ค
Item์ ์ข
๋ฅ
[A->X.Y] : X!=ฮต์ผ๋ kernel item [A->.X] : closure item [A->X.] : reduce item SLR ํ์ฑ ํ
์ด๋ธ ๋ง๋ค๊ธฐ reduce Item์ด [X->ฮฑ.]์ผ๋, FOLLOW(X)์ ๋ชจ๋ terminal์๋ง reduce action์ ๋ฃ๋๋ค ๋๋จธ์ง๋ LR(0)๊ณผ ๋๊ฐ๋ค LR(0)๋ณด๋ค conflict๊ฐ ์ ์ด, ๋ ์ ๊ตํ๋ค๊ณ ํ ์ ์๋ค. LALR Parsing ์ ๊ตํ ์์ LR(0) < SLR < LALR(1) < LR(1)
ํ์ ์ํ์ ๊ฐ์ SLR = LALR « LR(1)
SDD, AST SDD (Syntax Directed Definition) SDD : semnatic action์ ์ ์ํ๋ ์ถ์์ ์ธ ๋ช
์ธ์ Semnatic Actions : ๊ท์น์ ๋ํ Action Yacc/Bison : $$, $1, $2, ... ์ฌ์ฉ ANTLR : $<name> ์ฌ์ฉ Type declaration Attribute ์ข
๋ฅ synthesized attr. : children์ ์ํด ๊ณ์ฐ (terminal) inherited attr. : parent, sibling์ ์ํด ๊ณ์ฐ AST (Abstract Syntax Tree) ํ์คํธ๋ฆฌ์์ ๋ถํ์ํ ์ ๋ณด๋ฅผ ์ ๊ฑฐํ ํํ AST๋ฅผ ๋ง๋๋ ๋ฐฉ๋ฒ ํ์ฑ๋จ๊ณ์์ ๋ง๋ค๊ธฐ : LL, LR ํ์คํธ๋ฆฌ๋ฅผ ์ํํ๋ฉด์ ๋ง๋ค๊ธฐ : SDD ์ฌ์ฉ (Yacc etc.) evaluation : ๋
ธ๋๋ฅผ ๋ฐฉ๋ฌธํ๋ฉด์ ์์
ํ๋ ํ์ On-the-fly evaluation S-attributed SDD: synthesized attribute๋ง ๊ฐ์ง๊ณ ์๋ SDD L-attributed SDD: synthesized attribute๋ง ๊ฐ์ง๋ ๊ฒฝ์ฐ + ๊ฐ์ด ์ผ์ชฝ์์ ์ค๋ฅธ์ชฝ์ผ๋ก ํ๋ฌ ๊ณ์ฐ์ด ์ด๋ฃจ์ด์ง๋ ๊ฒฝ์ฐ IR (Intermediate Representation) IR์ด๋? Tree๋ Instruction list ํํ instruction(node)๊ฐ ์ ์ด์ผ ์ต์ ํ/๋ฒ์ญ์ ์ข์ High Level IR High์ Low๋ ์๋์ ์ธ ๊ฐ๋
High level IR: ์ฌ๊ธฐ์๋ AST์ ๋ณํ๋ง ์๊ฐ ์ข
๋ฅ : AST, TCOL Low Level IR ๋จ์ํ instruction์ผ๋ก ๊ตฌ์ฑ ๊ฐ์๊ธฐ๊ณ(์ฃผ๋ก RISC)๋ฅผ emulate N-tuple ํ๊ธฐ๋ฒ (3-address code) a = b OP c
์ผ๋ฐ์ ์ผ๋ก ๊ธฐ๊ณ์ด๊ฐ ๊ฐ์ง๋ ํผ์ฐ์ฐ์ ๊ฐ์ <= 3 quadruple : (์ฐ์ฐ์, ํผ์ฐ์ฐ์1, ํผ์ฐ์ฐ์2, ๊ฒฐ๊ณผ) Stack machine code Java byte code, U-code : AST๋ก๋ถํฐ ์์ฑ์ด ์ฉ์ด Tree ํํ ๊ธฐ๊ณ์ด ์์ฑ ์ฉ์ด IR ์์ GCC - GIMPLE (3-address code) GCC์ ์ค๊ฐ์ฝ๋ : GENERIC -> GIMPLE -> RTL 1D.1954 = x*10 // D.1954๋ ์์๋ณ์ 2gimple_assign <mult_exprt, D.1954, x, 10> LLVM - bit (3-address code) LLVM IR : ์ธ์ด์ ๋จธ์ ์ ๋
๋ฆฝ์ 1@var = global i32 14 ; ์ ์ญ๋ณ์ var์ 14 ๋์
2define i32 @main() nounwind { ; i32(int) ๋ฐํํ 3 entry: 4 %a = alloca i32, align 4 ; ์ง์ญ๋ณ์ a ์ ์ธ, int ํ ๋น 5 %1 = load i32 * @var ; %1 ์์๋ณ์์ var๊ฐ ๋์
6 ret i32 %1 ; ์์๋ณ์ ๊ฐ ๋ฐํ 7} JVM - byte code (stack machine code) ๊ฐ์ ๊ธฐ๊ณ ์ฝ๋ (Bytecode, MSIL) ๊ฐ์ ๊ธฐ๊ณ์์ ๋์ํ๋๋ก ํจ ์ด์์ฑ, ํธํ์ฑ์ด ๋ชฉ์ : java bytecode๋ machine ํธํ์ฑ, c# msil์ language ํธํ์ฑ 1public Employee(String strName, int num) 2{name = strName; idNumber = num; storeData(strName, num);} 3Method Employee(java.lang.String, int) 4 50 aload_0 ; 0๋ฒ์งธ ๋ก์ปฌ๋ณ์(this)๋ฅผ ์คํ์ push 61 invokespecial #3 <Method java.lang.Object()> ; ํจ์ ํธ์ถ 7--- 84 aload_0 95 aload_1 ; strName์ ์คํ์ push 106 putfield #5 <Field java.lang.String name> ; name์ strName ๋์
11--- 129 aload_0 1310 iload_2 ; num์ ์คํ์ push 1411 putfield #7 <Field int idNumber> ; idNumber์ num ๋์
15--- 1614 aload_0 1715 aload_1 ; strName์ ์คํ์ push 1816 iload_2 ; num์ ์คํ์ push 1917 invokespecial #9 <Method void storeData(java.lang.String, int)> ; ํจ์ ํธ์ถ 2020 return line number : ๋ช
๋ น์ด ์์ํ๋ ๋ฐ์ดํธ ์ฃผ์ aload : ๊ฐ์ฒด๋ฅผ push, iload : ์ ์๋ฅผ push ์๋๋ aload๊ฐ ๋ช
๋ น, ์์ฃผ ์ฐ๋ ๋ช
๋ น aload 0์ ๋ฌถ์ด์ bind -> aload_0 CIL (Common Intermediate Language) (stack machine code) C#, VB.NET, J# ๋ฑ์์ ์ฌ์ฉ MSIL์ ์๋ ์ด๋ฆ 1.assembly Hello {} ; .assembly: ์ด์
๋ธ๋ฆฌ ์ ์ธ 2.assembly extern mscorlib {} 3.method static void Main() { 4 .entrypoint 5 .maxstack 1 6 ldstr "Hello, world!" ; stack์ ์ ์ฅ 7 call void [mscorlib]System.Console::WriteLine(string) 8 ret 9} GCC RTL(Register Transfer Language) (Tree๊ตฌ์กฐ ์ฝ๋) Lisp S-expression ์ฌ์ฉ 1(set (reg:SI 140) 2 (plus:SI (reg:SI 138) 3 (reg:SI 139))) => reg140 = reg138+reg139 IR generation 3-address Translation ๊ท์น Binary operations: t = [[el OP e2]] Unary operations: t = [[OP el]] Array access: t = [[ v[e] ]] Structure access: t = [[ v.f ]] Short-circuit OR: t = [[ el SC-OR e2]] Statement sequence: [[s1; s2; ...; sN]] Variable assignment: [[ v = e ]] Array assignment: [[ v[e1] = e2 ]] If: [[ if(e) then s ]], [[ if(e) then s1 else s2]] While: [[ while (e) s ]] Switch: [[ switch (e) case v1:s1, ..., case vN:sN ]] Function Call: [[ call f(e1, e2, ..., eN) ]] Fucntion Return: [[ return e ]] Statement Expression Statement๋ expression ์ฒ๋ผ ๊ฐ์ ๊ฐ์ง๋๋ก ํ์ฅ t = [[ S ]]๋ฅผ ์ถ๊ฐํ์ฌ ๊ฒฐ๊ณผ๊ฐ์ ์ ์ฅํ์ Nested Expressions t = [[ (a - b) * (c + d) ]] t = [[ if c then if d then a = b ]] ๊ฐ์ฅ ํฐ ๋ฉ์ด๋ฆฌ๋ถํฐ ๋ฐ๊พผ๋ค Storage Management 2๊ฐ์ง Storage Register : ๋น ๋ฅธ ์ ๊ทผ, ๊ฐ์ ์ ๊ทผ ๋ถ๊ฐ Memory : ์๋์ ์ผ๋ก ๋๋ฆฐ ์ ๊ทผ, ๊ฐ์ ์ ๊ทผ ๊ฐ๋ฅ 2๊ฐ์ง ์ ๊ทผ ๋ฐฉ์ All memory approach ๋ชจ๋ ๋ณ์๋ฅผ memory์ ์ ์ฅ, ๊ฐ๋ฅํ๊ฒ๋ง register Standard approach Global, Statics, Local(composite)๋ memory์ ์ ์ฅ Local(scalar)๋ memory ๋๋ virtual register์ ์ ์ฅ Memory์ 4๋ ์์ญ Code space : ๋ช
๋ น์ด๋ฅผ ์ ์ฅ read-only์ผ๋ ๋น ๋ฆ Static data : ํ๋ก๊ทธ๋จ๊ณผ lifetime์ ํจ๊ปํ๋ ๋ฐ์ดํฐ Stack : Local ๋ณ์๋ค Heap : ๋์ ์ผ๋ก ํ ๋น๋๋ ๋ฐ์ดํฐ File Format Windows : PE (Portable Executable) Unix : ELF (Executable and Linkable Format) ๋ณ์ ๋ฐ์ธ๋ฉ environment : <๋ณ์, storage location> ์ ๋ณด state: <๋ณ์, ๊ฐ> ์ ๋ณด ์ด๋ค ๋ณ์ N์ด storage location S์ ์ง์ ๋๋ฉด ๋ฐ์ธ๋ฉ ๋๋ค๊ณ ํ๋ค Static Allocation ํ๋ก๊ทธ๋จ ์ํํ๋ ๋์ ๋ณํ์ง ์๋ location์ผ๋ก ๋ฐ์ธ๋ฉ Heap Allocation ์ฐ์์ ์ธ global ์์ญ์ ์ผ๋ถ๋ฅผ OS๋ก๋ถํฐ ๋ฐ์ ๊ฒ ํ๋ก๊ทธ๋จ ์ํ ์ค ์์ฒญ๊ณผ ๋ฐํ Stack Management Run-time stack : ํ ํจ์ call๋ง๋ค ํ๋์ฉ๋๋ frames Activation record : ํจ์ ์ํ์ ์ํ execution env(local var, parameter, return address, etc.) Top frame : ํ์ฌ ์ํ์ค์ธ ํจ์์ frame Stack pointers SP : Frame top FP : Frame base ๋ ๊ฐ๋ฅผ ์ฐ๋ ์ด์ ๊ฐ๊น์ด ๊ฑฐ ๊ธฐ์ค์ผ๋ก offset ๊ณ์ฐ -> small offset ์ ์ง ์ํ ์ค top frame์ ์์น๋ฅผ ์ ์ ์์ Semantic Analysis - Symbol Tables Scope Identifier: ์๋ณ์ Lexical Scope: ํน์ ๋ฒ์ ์๋ณ์์ Scope: ๊ทธ ์๋ณ์์ ์ ์ธ์ด ์ฐธ์กฐ๋๋ lexical scope Symbol Table Name Kind Type Attribute foo func int, int -> int extern m arg int tmp var char const ํ๋์ lexical๋ง๋ค ํ๋์ symbol table symbol table์ ๊ณ์ธต์ ์ด๋ค ํ์ฌ scope์ ์์ผ๋ฉด ์์ scope๋ก ์ฌ๋ผ๊ฐ๋ฉด์ ์ฐพ๋๋ค Symbol Table Implementation AST๊ฐ ๋ง๋ค์ด์ ธ์ผ ๊ฐ๋ฅ Local Table์ hash table ์ฌ์ฉ Global Table์ N-array tree ๊ตฌ์กฐ ์ฌ์ฉ ์ฝ๋๋ฅผ ์์ฐจ๋๋ก ์ฝ์ผ๋ฉด์ ๋ง๋ฌ (scope ์คํ์ ์ฌ์ฉ) Type Checking Type Expressions Array types: T[], T[10] Structure types : {id1: T1, id2: T2 …} Pointer types: T* Function types: T1 X T2 X … X Tn -> T_return Type Judgement A โ E : T A ์ํฉ์์ E๋ Tํ์
์ ๋ง์กฑํ๋ค
A โ if(E) S1 else S2 : T ์ ์กฐ๊ฑด์ ๋ชจ๋ E, S1, S2, A, T์ ๋ํ ๊ฐ์ ์ด ์ฑ๋ฆฝํ ๋ ๊ฒฐ๋ก T๊ฐ ์ฑ๋ฆฝํ๋ค
Proof Tree (ํ์
์ ๋ ํธ๋ฆฌ) ์ญ์ผ๊ฐํ ๋ชจ์ ๋ง์กฑํ๋ proof tree๊ฐ ์๋ค -> ํ์
์ค๋ฅ๊ฐ ์๋ค ๊ทธ ์ธ Semantic Analyses break, continue, goto ๋ฌธ์ด ์ฌ๋ฐ๋ฅธ ์์น์ ์๋ ์ง ๋ฑ ์ปดํ์ผ๋ฌ ํ๋ฐ๋ถ (๋น ๋ฅด๊ณ , ์ค์ ๋์๊ฐ๋ ์ฝ๋๋ก ๋ฐ๊พธ๊ธฐ) Instruction Selection Tree ๊ธฐ๋ฐ Intermediate Representation MEM(e) : ์ฃผ์ e๋ก ์์ํ๋ ๋ฉ๋ชจ๋ฆฌ ํ word์ ๋ด์ฉ TEMP(t) : ๋ ์ง์คํฐ t SEQ(s1, s2): ๋ฌธ์ฅ s1 ์ํ ํ s2 ์ํ ESEQ(s, e): ๋ฌธ์ฅ s ์ํ ํ (๊ฒฐ๊ณผ ์์) e๊ฐ ์ถ๊ฐ ์ํ BINOP(o, e1, e2) : ์ฐ์ฐ์ o, ํผ์ฐ์ฐ์ e1, e2, ๊ฒฐ๊ณผ ์ ์ฅ๋ ์ฃผ์ ๋ฐํ const(i): ์ ์ ์์ i Register Allocation ์ต์ ํ ํ๊ธฐ ์ํด ์ต๋ํ ์์ฃผ ์ฌ์ฉ๋๋ ๊ฒ์ Register์ ์ ์ฅ Interference ์๋ก ๋ค๋ฅธ ๋ definition์ด live range ์์ ๊ณตํต operation์ ๊ฐ์ง๊ณ ์๋ ๊ฒฝ์ฐ
Interference Graph : ์๋ก interfere ํ๋ฉด ์ฐ๊ฒฐํ๋ ๊ทธ๋ํ Graph coloring : ์ฐ๊ฒฐ๋ ๋
ธ๋๋ ๋ค๋ฅธ ์์ผ๋ก ์น ํ๊ธฐ Instruction Scheduling instruction์ ์์๋ฅผ ๋ฐ๊พธ์ด stall ๊ฐ์ ๋ฑ์ ์ค์ฌ์ ์ํ์๋๋ฅผ ๋์ด๋ ๊ฒ
stall : ๋ค๋ฅธ ๋ช
๋ น์ด ์ํ์ ๊ธฐ๋ค๋ฆฌ๋๋ผ CPU๋ฅผ ๋ญ๋นํ๋ ๊ฒ ๋ชฉํ Wasting time์ ์ค์ธ๋ค ๋์ผํ ์ฝ๋๊ฐ ๋์์ผํ๋ค register spilling์ ํผํด์ผํ๋ค Static scheduling ๋จ๊ณ Local basic scheduling, Loop scheduling, global scheduling Local basic scheduling List scheduling : greedy, heuristic, local technique ์ฌ์ฉ precedence graph๋ฅผ ๋ง๋ ๋ค ๊ฐ ๋
ธ๋์ priority function์ ์ ์ฉํ๋ค “ready-operation queue"๋ฅผ ์์ ready operation์ ํ๋ ์ ํ ํ scheduling, ready operation queue๋ฅผ ์
๋ฐ์ดํธํ๋ค. Longest latency-weighted path๋ฅผ ์ด์ฉํด์ ์ฐ์ ์์๋ฅผ ์ ํ๋ค ๊ธฐํ Optimization ๋ฐฉ๋ฒ addr r1 1 -> inc r1 ํน์ ์ฑ์ง์ ๋ ์ง์คํฐ ํ์ฉ ํน์ ๋ชฉ์ ์ ๋ช
๋ น์ด ํ์ฉ Register ๊ฐ mov ์ ๊ฑฐ ์ค๋ณต๋ load ์ ๊ฑฐ Control Flow Optimizations(์ต์ ํ) ์ฃผ์ด์ง ์
๋ ฅ ํ๋ก๊ทธ๋จ์ ์ข ๋ ํจ์จ์ ์ธ ์ฝ๋๋ก ๋ฐ๊พธ๋ ๊ฒ
์ฌ๋ฌ๊ฐ์ง ๋ถ๋ฅ ๋ฐฉ๋ฒ ๋ถ์ : Control Flow Analysis vs Data Flow Analysis ์ต์ ํ Inner basic block(local) vs Inter basic block(global) Cyclic code opt vs Acyclic code opt Control Flow Analysis Control Flow ํ๋ก๊ทธ๋จ์ ๊ฐ๋ฅํ ์ํ์์ (๋ถ๊ธฐ)
Branch Execution -> dynamic control flow : ์คํ ํด๋ด์ผ ํ์ธ ๊ฐ๋ฅ Compiler -> static control flow : ์ปดํ์ผ๋ฌ๊ฐ ๋ถ์ํด์ ์ ์ ์์ Analysis ์ ์ ์ฑ์ง (static property): ํ๋ก๊ทธ๋จ ์ํ ์์ด ๋์ถ ๋๋ ์ฑ์ง CFA(Control Flow Analysis) : ์ฝ๋์ ๋ถ๊ธฐ ๊ตฌ์กฐ๋ฅผ CFG ํํ๋ก ํํ Basic Block ๋์ผํ execution condition์ ์ ์ฉ๋ฐ๋ instruction ๋ฌถ์
instruction ์ธ์๋ branch๊ฐ ์์ Maximal basic block ๊ตฌํ๊ธฐ BB์ leader(์ฒซ๋ฒ์งธ instruction)๋ฅผ ์ฐพ๋๋ค ๋ค์ leader ์ด์ ๊น์ง์ instruction์ ๊ตฌํ๋ค Weighted CFG Profiling: ๋ฐ๋ณตํด์ ์ํํด๋ณด๋ฉด์ ์คํํ์๋ฅผ ์ป์ ์ป์ weight๋ฅผ edge์ ํ์ Control Flow Optimization Acyclic Code Loop๊ฐ ์๋ ์ฝ๋
๋ถ์ ๋ฐ ์ต์ ํ๊ฐ ์๋์ ์ผ๋ก ์ฌ์
์ข
๋ฅ
Inner basic block opt. = Intra opt. = Local opt. Inter basic block opt. = Global opt. Inner Basic Block Optimization Commn subexpression elimination ๊ณตํต๋ ๋ถ๋ถ์ด ์์ผ๋ฉด ํ๋ฒ๋ง ๊ณ์ฐ Algebraic simplification ๋์๋ฒ์น์ ์ด์ฉํ์ฌ ์์ ๊ฐ์ํ ex) x=1*y; -> x=y; Strength reduction ์ฐ์ฐ์์ ๋น์ฉ์ด ์ ์ ๊ฒ์ผ๋ก ๋ฐ๊พธ๊ธฐ ex) x=x*2; -> x=x+x; ex) y=a/4; -> y=a>>2; Constant folding / propagation folding: ์ปดํ์ผ ์๊ฐ์ ์์์์ ์ง์ ์๊ฐ propagation : ๊ณ ์ ๋ ๊ฐ์ ๊ฐ์ง๋ ๋ณ์๋ฅผ ์์๋ก ๋์ฒด Inter Basic Block Optimization Global application of inner basic block optimization
Global common subexpression elimination basic block ๊ฐ์ ๊ณตํต ๋ถ๋ถ์์ ๋ํด ํ๋ฒ๋ง ๊ณ์ฐ Global constant folding / propagation basic block ๊ฐ์ ์์๋ฅผ ์ธ์ํ์ฌ ํ๋ฒ๋ง ๊ณ์ฐ Other transformation
Branch to unconditional branch ๋ถํ์ํ ๋ถ๊ธฐ ์ ๊ฑฐ Unconditional branch to branch ๋ถ๊ธฐ ํ ๋ฐ๋ก ๋ถ๊ธฐ -> ๋ถ๊ธฐ ํ๋ฒ์ผ๋ก ๋ณ๊ฒฝ Branch to next basic block (next instr) ๋ถ๊ธฐ ํ ๋ฐ๋ก ๋ค์ basic block์ผ๋ก ๋ถ๊ธฐ ์ ๊ฑฐ Basic block merging ๋ basic block์ ํฉ์นจ Branch to same target ๊ฐ์ basic block์ผ๋ก ๋ถ๊ธฐํ๋ ๊ฒ์ ์ ๊ฑฐ Branch target expansion ๋ถ๊ธฐ ๋์์ด ๋๋ basic block์ ํฉ์นจ Unreachable code elimination Entry์์ ๋๋ฌํ ์ ์๋ ‘unreachable’ block ์ ๊ฑฐ Loop Optimization Loop๋ ํ๋ฒ optimizeํ๋ฉด ํจ๊ณผ๊ฐ ํฌ๋ค Loop unrolling : ๋ฐ๋ณต๋ฌธ์ ํ์ด์ ๋ฐ๋ณต ํ์๋ฅผ ์ค์ Loop invarient : ๋งค๋ฒ ๋์ผํ ๊ฐ์ ๋ด๋ ๋ฌธ์ฅ์ ๋ฐ๋ณต๋ฌธ ๋ฐ์ผ๋ก ๋นผ๋ Count up to zero : i๋ฅผ ๊ฐ์ํ๋ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ณ๊ฒฝ (i๋ฅผ 0๊ณผ ๋น๊ตํ๋ ๊ฒ์ด n๊ณผ ๋น๊ตํ๋ ๊ฒ๋ณด๋ค ๋น ๋ฆ) Dataflow Analysis + Optimization Dataflow Analysis ํ๋ก๊ทธ๋จ ๋ด์ ๊ฐ data ๊ฐ๋ค์ด ์์ฑ/์๋ฉธ๋๋ ์ ๋ณด๋ฅผ ๋ชจ์ผ๋ ๊ฒ Reaching Definition Analysis definition : ํด๋น ๋ณ์๊ฐ assign๋๋ ๊ฒ reach : definition d๊ฐ ํน์ ์์น p์ ๋๋ฌํ๋ค kill : definition d์ ๋๊ฐ์ ํฌ์ธํธ์ฌ์ด์์ ๋ค๋ฅธ definition์ด ์กด์ฌํ๋ค GEN/KILL GEN: ๋ธ๋ก ๋ด์์ ์์ฑ๋ definition KILL: ๋ธ๋ก ๋ด์์ ์๋ฉธ๋ definition IN/OUT IN : ์ด์ ๋ธ๋ก์ OUT์ ํฉ์งํฉ OUT : IN์์ GEN์ ๋ํ๊ณ KILL์ ๋บ ๊ฒ ๊ธ๋ก๋ฒ ๋งค๋ ๋งค๋ ์ธ๊ฐ๊ด๊ณ๋ฅผ ๋งบ๋๋ฐ ์์ด ์ค์ํ ์์
์ด์ : Manus(์, ํ๋, ์ต๊ด) + Arius(๋ฐฉ๋ฒ, ๋ฐฉ์)
๋งค๋์ ๊ธฐ๋ณธ(1)
๋ค๋ฅธ ์ฌ๋์ ์ธ๊ฒฉ์ ์กด์คํ๊ณ , ๋ฐฐ๋ คํ๋ ๋ง์์ ๊ฐ์ง๊ณ , ํธ์ํ๊ฒ ํด์ฃผ๊ฑฐ๋ ๊ธฐ์๊ฒ ๋ง๋ค๋ ค๋ ํ๋๋ฐฉ์
๋งค๋์ ๊ธฐ๋ณธ(2)
์ญ์ง์ฌ์ง (ๆๅฐๆไน)
๋งค๋์ ๊ธฐ๋ณธ(3)
ํ์์ ์น์ฐ์น์ง ๋ง๊ณ , ๋ฐฐ๋ คํ๋ ๋ง์์ ์ ๋ฌํ๋ ๊ฒ
๋งค๋์ ์ํฐ์ผ์ ์ฐจ์ด ๋งค๋(์์) : ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅด๊ฒ ํํ ๊ฐ๋ฅ ์ํฐ์ผ(๋ฒ์ ) : ํ์๊ณผ ์ ์ฐจ๋ฅผ ์ค์์ ํจ ๋์์ ๋งค๋ 5๋
์ธ, ์, ์, ์ง, ์
5๋ฅ
๊ตฐ์ ์ ์ : ์๊ธ์ ์๋ก์์ผ ํ๊ณ ์ ํ๋ ์ถฉ์ฑ์ค๋ฌ์์ผ ํ๋ค ๋ถ์์ ์น : ๋ถ๋ชจ๋ ์๋
์๊ฒ ์ธ์ํ๊ณ ์๋
๋ ๋ถ๋ชจ๋ฅผ ๊ณต๊ฒฝํด์ผํ๋ค. ๋ถ๋ถ์ ๋ณ : ์๋ก์ ์ญํ ์ ์นจ๋ฒํ์ง ์์์ผ ํ๋ค ์ฅ์ ์ ์ : ์ด๋ฅธ๊ณผ ์ด๋ฆฐ์์ด ์ฌ์ด์๋ ์ง์๊ฐ ์์ด์ผ ํ๋ค ๋ถ์ฐ์ ์ : ์น๊ตฌ ์ฌ์ด์๋ ์ ๋ขฐ๊ฐ ์์ด์ผํ๋ค ์์์ ๋งค๋ (๊ธฐ์ : ์ฑ๊ฒฝ) ์๊ธฐ๋ฅผ ๋์ด๋ ์ฌ๋์ ๋ฎ์์ง๊ณ ์๊ธฐ๋ฅผ ๋ฎ์ถ๋ ์ฌ๋์ ๋์์ง๋ค ๋ค๊ฐ ๋์ ๋ฐ๊ณ ์ ํ๋ ๋๋ก ๋ค๋ฅธ ์ฌ๋์๊ฒ ํํ๋ผ ๋ค ์ด์์ ๋ค ๋ชธ์ฒ๋ผ ์ฌ๋ํ๋ผ ๋์์ ๋งค๋์ ์ฐจ์ด ๊ณตํต์ : ๋จ์ ์กด์คํ๊ณ ๋ฐฐ๋ คํจ ์ฐจ์ด์ : ๋์ -> ๋จ์ฑ์ฐ์ , ์์ -> ์ฌ์ฑ์ฐ์ ์๊ฐ์ ์ธ์ฌ 1 ์๊ธฐ์๊ฐ ์ฑ๊ณผ ์ด๋ฆ (OOO ์
๋๋ค)
์ฑ์ O๊ฐ, ๋ณธ๊ด์ OO ์
๋๋ค
์๋ฒ์ง ํจ์๋ ํ ๊ธธ์ ๋์ ์
๋๋ค
์๊ฐ๋ ์ผ์ด๋์
์๋๊ณผ ์ฃผ์ธ์ ์ธ์ฌ ์ ์๋์ด ๋จผ์ ์ธ์ฌํ๋ค
์งํฉ-์ด๋ฆ ์์ผ๋ก ์๊ธฐ์๊ฐ ํ๋ค
ํ์ฌ ์ง๊ธ ์ฌ์ฅ - ์ ๋ฌด - ์ด์ฌ - ๋ถ์ฅ - ์ฐจ์ฅ - ๊ณผ์ฅ - ๋๋ฆฌ - ์ฃผ์ - ์ฌ์
์๊ฐ ์์ ์์๋ซ์ฌ๋์ ์์์ฌ๋์๊ฒ ๋ฏธํผ์๋ฅผ ๊ธฐํผ์์๊ฒ ํ ์ฌ๋์ ๊ทธ๋ฃน์๊ฒ, ๊ทธ๋ฃน์์ ๋์ ์ฌ๋ ๋ถํฐ (๊ทธ๋ฃน ์ข์ธก ๋ถํฐ) ์๊ฐ ์ ๋งคํ ๊ฒฝ์ฐ “OO๋ถํฐ ์๊ฐ๋๋ ค๋ ๋ ๊น์?” ๋ฉํธ ์ง์, ์ฐ๋ น, ์ฑ๋ณ์ ๋ฌด์ํ๊ณ ์๊ธฐ ๊ฐ์กฑ์ ํ์ธ์๊ฒ ๋จผ์ ์๊ฐ ์์ ์๊ฐ ์๊ฐ ๋ชฉ์ ๊ณผ ๋ณธ์ธ๊ณผ์ ๊ด๊ณ๋ฅผ ๋ฐํ ๊ฐ๋ดํ ์ํ์๋ก ์๋ขฐํ ์ฌ๋์๊ฒ ์ ๋ฌ : ์๋ขฐ์๋ ๋ด์ฉ์ ํ์ธ ํ ๊ฒ ์๊ฐ์ฅ์ ์จ ์ฃผ์ ๋ถ์๊ฒ ์งํ์ํฉ ๋ง์๋๋ฆด ๊ฒ ์ธ์ฌ ๋ง๋ฌ์ ๋๋ ํค์ด์ง ๋ ์๋ฅผ ํํ๋ ๋ง์ด๋ ํ๋
์ธ์ฌ์ ๊ธฐ๋ฅ ์๋๋ฐฉ์ ๋ํ ํ์๊ณผ ํธ์๋ฅผ ํ์ ์๋๋ฐฉ๊ณผ์ ๊ด๊ณ๋ฅผ ์ค๋ช
ํด์ค๋ค ์ฒ์ ๋ง๋๋ ์๋์ ๋ํ ๊ฒฝ๊ณ์ฌ๊ณผ ๋ถ์๊ฐ ํด์ ๊ณต์ ๋ ์์ ๋ชจ์ ์์ผ๋ก ์ก๋ ๊ฒ ์ ์ ๊ธฐ๋ณธ ์์ธ ์์๋ซ ์ฌ๋์ ์์ธ ๋จ์๋ ์ผ์์ ์, ์ฌ์๋ ์ค๋ฅธ์์ ์ (ํ์ฌ ์ ๋ฐ๋๋ก) ์๋ก (์) ๊ณต์ํ ์์ ์ฌ๋ฆฌ๋ ๊ฒ (์ ํ๊ธฐ ์ ์) ์๊ฐ์ ์ธ์ฌ 2 ์ฐ๋ฆฌ๋๋ผ ์ ์ ์ข
๋ฅ ํฐ์ : ๋ถ๋ชจ๋, ์กฐ๋ถ๋ชจ๋๊ป, ์๋กํ์ฌ์, ์ฅ๋ก์๋ ์์ ์์ ํ์ : ์ฅ๋ก์์์ ์์ฃผ์ ํ๋ ์ ๋ฐ์ : ์์ด๋ฅธ์ด ์๋ซ์ฌ๋์ ์ ์ ๋ํด ๋ต๋ฐฐ ํ ๋ ์ฌ์ฑ์ ํฐ์ ๊ณต์์์ธ (์ค๋ฅธ์์ด ์๋ก) ๊ณต์ํ ์์ ์ด๊นจ ๋์ด๋ก ์ฌ๋ฆฐ๋ค. ๊ณ ๊ฐ๋ฅผ ์์ฌ์ ์ด๋ง๋ฅผ ์๋ฑ์ ๋ถ์ธ๋ค (์์ ๋์ด < ์ด๊นจ) ์ฒ์ฒํ ์์ผ๋ฉด์ ์ผ์ชฝ ๋ฌด๋ฆ์ ๋จผ์ ๊ฟ๋๋ค ์ค๋ฅธ๋ฐ์์ ์ผ๋ฐ์ ํฌ๊ฐ ๋ค (์์ด๋ ๋ฐ๋) ์๋ฉ์ด๋ฅผ ๋ด๋ ค ๊น๊ฒ ์๋๋ค ๋ชธ์ 45๋ ์์ผ๋ก ๊ตฝํ๋ค (์๋ฑ์ ์ด๋ง์์ ๋ผ์ง ๋ง๊ฒ) ์ค๋ฅธ์ชฝ ๋ฌด๋ฆ๋ถํฐ ์ผ์ด๋๋ค ์ ์ด ๋๋๋ฉด ์์ ๋ด๋ฆฐ๋ค ๊ณต์ํ ์ฑ ๋ชธ์ 15๋ ๊ตฝํ ์๋ฅผ ํํ (๊ตด์ ๋ก) ์ฌ์ฑ์ ํ์ ๊ณต์์์ธ (์ค๋ฅธ์์ด ์๋ก) ๊ณต์ํ ์์ ํ์ด ์์์ผ๋ก ๋ด๋ฆฐ๋ค ์ฒ์ฒํ ์์ผ๋ฉด์ ์ผ์ชฝ ๋ฌด๋ฆ์ ๋จผ์ ๊ฟ๋๋ค ์ค๋ฅธ๋ฐ์์ ์ผ๋ฐ์ ํฌ๊ฐ ๋ค ์๋์ด ๋ฐ๊นฅ์ ํฅํ๋๋ก ํ์ฌ ๋ฐ๋ฅ์ ๋๋ค ํ๋ฆฌ๋ฅผ 30๋ ๊ตฝํ๋ค๊ฐ ํ๋ฆฌ๋ฅผ ํด๋ฉฐ, ์์์ ๋ฐ๋ฅ์์ ๋ผ๊ณ ์ฒ์ฒํ ์ผ์ด๋๋ค ์ค๋ฅธ์ชฝ ๋ฌด๋ฆ๋ถํฐ ์ผ์ด๋๋ค ๊ณต์ํ ์ฑ ๋ชธ์ 30๋ ๊ตฝํ ์๋ฅผ ํํ (๊ตด์ ๋ก) ๋จ์ฑ์ ํฐ์ ๊ณต์์์ธ (์ผ์์ด ์๋ก) ์๋ก ๊ณต์ํ ์์ ๋์น ๋์ด๋ก ์ฌ๋ฆฐ๋ค ํ๋ฆฌ์ ๋ฌด๋ฆ์ ๊ตฝํ ๊ณต์ํ ์์ผ๋ก ๋ฐ๋ฅ์ ์ง๋๋ค ์ผ์ชฝ ๋ฌด๋ฆ์ ๋จผ์ ๊ฟ๋๋ค ์ผ๋ฐ์ด ์์ ๋๊ฒ ๋ฐ๋ฑ์ ํฌ๊ฐ ๋ค ํ๊ฟ์น๋ ์ด์ง ์๊ณ ๋ชธํต ์ชฝ์ผ๋ก ๋ถ์ด๊ณ ์ด๋ง๋ฅผ ๊ณต์ํ ์์ ๋๋ค ์ค๋ฅธ์ชฝ ๋ฌด๋ฆ๋ถํฐ ์ผ์ด๋๋ค ๊ณต์ ๋จ์์ ํ์ ๋ชจ๋ ๋์์ ํฐ์ ๊ณผ ๋์ผํ๋ค ๋ค๋ง ์๋ก๋ฅผ ํ์ง์๊ณ , ์ด๋ง๊ฐ ์๋ฑ์ ๋ฟ์ผ๋ฉด ์ฆ์ ์ผ์ด๋๋ค ๋ฐํ ์ฌ์ฑ : ํ์ ์์ ์์ธ๊น์ง ๋จ์ฑ : ๋ฌด๋ฆ์ ๊ฟ์ ์ํ์์ ๋จธ๋ฆฌ์ ์๋ฉ์ด๊ฐ ์ํ ์ดํ์ ๊ณต์์์ธ ํ์ X ๊ฒฝ๋ก 3๋ณด ์์์ ๋ฉ์ถค, ๋์ ๋ง์ฃผ์นจ, ์ธ์ฌ๋ง ๊ฑด๋ด, ๊ฒฝ๋ก, ๋ค์ ๋์ ๋ง์ฃผ์นจ ๋จ์๋ ์์ชฝ ์์ ๊ฐ๋ณ๊ฒ ์ฃผ๋จน์ ์ฅ ์ํ์์ ๋ฐ์ง ์์ค์ ๋๊ณ ๊ฒฝ๋ก ์ฌ์๋ ์์ผ๋ก ๋ชจ์ ๊ณต์ํ ์ํ์์ ๊ฒฝ๋ก ๊ฒฝ๋ก์ ์ข
๋ฅ ์๋ก์ ๊ฒฝ๋ก (90๋) : ๊ดํผ์์ ํฐ๊ฒฝ๋ก (45๋) : ํน๋ณํ ๊ฐ์ฌ, ์ฌ๊ณผ, ์กด๊ฒฝ ํ๊ฒฝ๋ก (30๋) : ํ์ ์ ๋ฐ๊ฒฝ๋ก (15๋) : ์นํ ์ฌ์ด ๋ชฉ๋ก ๋ฐ๋ณต์ ์ธ ๋ง๋จ ๋ณดํ ์ค ์ผ๋ฐ ๊ฒฝ๋ก๋ฅผ ํ ์ ์์ ๋ ์
์ ์์์ฌ๋์ด ์์๋ซ์ฌ๋์๊ฒ ์ฒญํจ ์์๋ซ์ฌ๋์ ๊ฐ๋ฒผ์ด ๋ชฉ๋ก๋ฅผ ํ๋ฉด์ ์
์ ์ด์ฑ ๊ฐ์๋ ์ฌ์ฑ์ด ๋จผ์ ์
์๋ฅผ ์ฒญํจ (๋ชฉ๋ก, ๋ฏธ์๋ก ๋์ฒด ๊ฐ๋ฅ) ์ ์ ํ ์ธ์ฌ๋ง ์์์ฌ๋์๊ฒ ์๊ณ ํ์ญ์์ค X ์ธ๊ณ ๊ฐ ๊ตญ์ ์ธ์ฌ๋ฒ ์ธ๋ ๋๋ง์คํ
(๋๋ง : ์ธ์ฌํ๋๋ค, ์์ค : ๋, ํ
: ๋)
๋๋ ๋น์ ํํ
์ธ์ฌํฉ๋๋ค
์ค๋ ์์ฌ๋ ์๋ผ์ด์ฟฐ (์์ด๋: ํํ๊ฐ, ์๋ผ์ด: ~์์, ์ฟฐ: ๋น์ ๋ค)
์ค๊ตญ ์ ํ๋ค๊ธฐ (๋์ด์ ์๊ด์์ด)
๊ณต์ (์์ด ๊ฐ์ด์์ ์์น)
ํ๊ตญ ์์ด (Wai) : ์์ ํฉ์ฅํ ๋ชจ์ต์ด Y์ ๋น์ท
์์๋ซ์ฌ๋์ด ๊ณ ๊ฐ๋ฅผ ๊น์ด ์์ด๊ณ , ์์ ๋์ด ๋ ๋ค
์ฌ์๋์บ
: ์๋
ํ์ธ์
๋ช
ํจ ๋งค๋ ๋ช
ํจ์ ๊ธฐ๋ฅ ์๊ธฐ๋ฅผ ์๊ฐํ๊ณ ์๋๋ฐฉ์ผ๋ก ํ์ฌ๊ธ ์๊ธฐ๋ฅผ ๊ธฐ์ตํ๊ฒ ํจ ์ธ๊ฐ๊ด๊ณ ํ์ฑ๊ณผ ์ธ๋งฅ๊ด๋ฆฌ์ ์ค์ํ ๋๊ตฌ ์น๋ถ์ ์์ : ์ฒซ ์ธ์์ ์ข์ฐ, ์๋ฅผ ๋คํด์ผ ํจ ๋ช
ํจ์ ์ข
๋ฅ ์ฌ๊ต์ฉ ๋ช
ํจ (์ฑ๋ช
, ์ฃผ์) ๋ฉ์์ง ์นด๋๋ ์ด์ฒญ์ฅ ๋์ ์ฌ์ฉ ์
๋ฌด์ฉ ๋ช
ํจ (์ฌ์ง, ์ฑ๋ช
, ์ง์ฅ ์ฃผ์, ๋ก๊ณ ๋ฑ) (๋ฏธ๊ตญ) ์ฌ์ฅ, ์ค์ญ์ฉ : ๋ช
ํจ ์ค์์ ์ด๋ฆ, ํ๋จ์ ์ง์์ ํ์ฌ๋ช
(๋ฏธ๊ตญ) ์ฌ์์ฉ : ์ค์์ ํ์ฌ๋ช
, ์ข์ธก ํ๋จ์ ์ฑ๋ช
, ์์๋ถ์, ์ฃผ์ ๋ฑ ๋ช
ํจ ๊ตํ ๋ฐฉ๋ฒ ์๊ฐํ๊ณ ์๋ก ๋ช
ํจ๋ถํฐ ๊ตํ
(์์) ํค์ด์ง ๋ ํ์ํ ๊ฒฝ์ฐ ๊ตํ
๋ช
ํจ์ ์ค ๋
๋ช
ํจ์ ๋ช
ํจ ์ง๊ฐ์ ๋ฃ์ด์ ์ ๊ณ ๋ฆฌ ์์ฃผ๋จธ๋์ ๋ณด๊ด ์ -> ๊ฐ ์ ์์ธ์์ ๊ตํ ํ๋ค. ํ
์ด๋ธ ์์ ๋๊ณ ๋ฐ๊ฑฐ๋, ์๋ฅ ๋ดํฌ์ ํจ๊ป X ์ผ์ด์์, ์ ์คํ๊ฒ ์ธ์ฌํ๊ณ , ์ด๋ฆ์ด๋ ์์์ ๋ฐํ๋ฉด์, ๋ ์์ผ๋ก ๊ฑด๋จ๋ค ๋ช
ํจ ๊ธ์๊ฐ ์๋๋ฐฉ ์ชฝ์์ ๋ฐ๋ฅด๊ฒ ๋ณด์ด๊ฒ ๊ฑด๋จ๋ค ์์ฌ๊ฐ ๋จผ์ ๊ฑด๋ค๊ณ ์๊ธฐ ๋ช
ํจ์ ๊ฑด๋ฌ ๊ฒ ์๋๊ฐ ๋ ์ฌ๋ ์ด์์ด๋ฉด ์์ฌ๋์๊ฒ ๋จผ์ ๊ฑด๋จ๋ค ์ค๊ฐ์ ํ
์ด๋ธ ๊ฐ์ ์ฅ์ ๋ฌผ์ด ์๋ค๋ฉด ๋ ์ฌ์ด์ ์ฅ์ ๋ฌผ์ด ์๋ ์ํ์์ ๋ช
ํจ์ ๊ตํํ ๊ฒ ๋ช
ํจ์ ๋ฐ์ ๋
์ผ์ด์์, ๋ ์์ผ๋ก, ๋ชจ์๋ฆฌ๋ฅผ ์ก๊ณ (๋ช
ํจ์ ๊ฐ๋ฆฌ์ง ์๊ณ ) ๋ฐ๋๋ค ๋ฐ์ผ๋ฉด ์์ ์ ๋ช
ํจ์ ์ค ๊ฒ, ํ ์ฌ๋์ฉ ์ฃผ๊ณ ๋ฐ๋๋ค ์๋๋ฐฉ์ ๋ช
ํจ์ ๋๊ณ ๊ฐ๋ ๊ฒ์ ์ค๋ก ํ์ ํ ๋ ์๋ฆฌ์ ๋ฐ๋ผ ํ
์ด๋ธ์ ๋ช
ํจ์ ์ฌ๋ ค ๋์ ์ ์์ ์๋๋ฐฉ์ ๋ช
ํจ์ ์ฝ๊ณ ์ง๊ฐ์ ๋ฃ์ ๊ฒ ๋ช
ํจ ๋ณด๊ด
๋ช
ํจ ํ๋๋ ๋ฐ์ธ๋์ ์ ์ ๋ฆฌ (์ง์ฅ๋ณ, ๊ฐ์ธ๋ณ, ๋ชจ์๋ณ) ๋ช
ํจ์ ๊ธฐ์ฌ๋ ์ฌํญ์ด ๋ณ๊ฒฝ๋๋ ๊ฒฝ์ฐ ์ฌ๋ฐฑ์ ๋ฉ๋ชจ ์ฐ 1ํ ์ ๋ฆฌ ์ฌ๊ต๋งค๋ ๋ฐฉ๋ฌธ ์ ๋ ์์ ์ถ์ฐ ๋ฐฉ๋ฌธ ๋ฐฉ๋ฌธ ์ ๊ธฐ๋ณธ ๋งค๋ ๋ฐฉ๋ฌธ์ ํ ๊ฒฝ์ฐ ๋ฐฉ๋ฌธ์ ๋ํ ์ฝ์์ด ์ ํ
์
๋ฌด ๊ด๋ จ ๋ฐฉ๋ฌธ์ด ์๋๋ผ๋ฉด, ๋ถ๋ถ ๋๋ฐ
์๋๋ฐฉ์ ์ทจํฅ ๊ณ ๋ ค ์ ๋ฌผ ์ค๋น
๋ฐฉ๋ฌธ ์๊ฐ : ์คํ 3์~5์ ์ ๋น
๋ณ๋ฌธ์, ์กฐ๋ฌธ ์ ์ธํ๊ณ ๋ ์ค์ ์๊ฐ์ ์ผ๊ฐ
๊ฐ์ ์ผ๋ก์ ๋ฐฉ๋ฌธ ์ด์ธ์ข
์ ๋๋ฅด๊ธฐ ์ ์ ์ท์ฐจ๋ฆผ๊ณผ ๋ฐฉ๋ฌธ ๋ชฉ์ ์ ์ ๊ฒ
์ค๋นํ ์ ๋ฌผ์ ์์ฃผ์ธ์๊ฒ ์ ๋ฌ
๊ฑฐ์ค์์๋ ์
๊ตฌ ๊ฐ๊น์ด ๊ณณ์ด ํ์, ๊ทธ ๋ฐ๋๊ฐ ์์
์์ ์ค์ ๊ธด ์ํ์ ์๋ฝ์์๊ฐ ์์ ๋ ๊ธด ์ํ๊ฐ ์๋์ฉ
์์ฌ์๊ฐ์ ํผํ๋ ๋ถ๋์ดํ ๊ฒฝ์ฐ ๋๋ฌด ์ฌ์ํ์ง ์๋๋ก
๋ถ์ฌ ์๋ ๋ช
ํจ์ ๋จ๊ธฐ๋๋ก
๋ฐฉ๋ฌธ ํ ๋ฐ๋์ ์ ํ๋ก ๊ฐ์ฌ๋ฅผ ํ์
์ง์ฅ์ผ๋ก์ ๋ฐฉ๋ฌธ ๋
ธํฌ๋ฅผ ํ ํ ์
์คํ ๊ฒ
๊ณต์ฉ์ฌ๋ฌด์ค์ธ ๊ฒฝ์ฐ ๋๋ฃ ์ง์๋ค์๊ฒ ๊ฐ๋จํ ๋ชฉ๋ก
์๋๋ฐฉ์ ์ผ์ ์ ํ์
๋ณ์์ผ๋ก์ ๋ฐฉ๋ฌธ ๋ณ๋ฌธ์์ ๋น ๋ฅผ ์๋ก ์ข์ผ๋ฉฐ ๋ฐฉ๋ฌธ์ ์ ๋ฏธ๋ฆฌ ์๋ฆด ๊ฒ
๋ฌธ๋ณ ์๊ฐ: 20~30๋ถ์ด ์ ๋น
์์ฌ์๊ฐ๊ณผ ์น๋ฃ์๊ฐ์ ํผํด ์คํ 2์ ~ 5์
ํ์๊ฐ ์ํ๋ ๊ฒ์ ๋ฌผ์ด๋ณด์ ์ค๋น
๊ฝ์ ์ผ๊ฐ (๊ฝ๊ฐ๋ฃจ)
์ ๋ ์ ๋๋งค๋ ์์ ์ค๋ก ์๋ดํ๋ฉฐ ์๋ฆฌ๋ฅผ ๊ถํ ํ ์๋์๊ฒ ๊ฐ์กฑ๋ค์ ์๊ฐ
์๋์ด ์์งํ ๋๋ ์ฅ์ ๋ง๋ จ
์ฐจ๋ ์๋ ์ํฅ์ ๋ฌผ์ด ๋์
์ ๋ฌผ์ ์๋ฆฌ์์ ์ด์ด๋ณด์ง ๋ชปํ๋ค๋ฉด ์์คํ ์ทจ๊ธ
์๋์ด ๋์๊ฐ ๋ ์ง์์ ์ค๋นํ ๊ฐ๋จํ ์ ๋ฌผ๋ก ๋ต๋ก
ํ๊ด์ด๋ ์ฐจ๋ฅผ ํ๋ ๊ณณ๊น์ง ๋ฐฐ์
์์์ฌ๋์ธ ๊ฒฝ์ฐ ๋์ค์ ์ ๋์ฐฉํ์
จ๋์ง ํ์ธ ์ ํ ํ์
์ ๋๋งค๋ (์ง์ฅ) ๊ณตํญ์ ๋ง์ค์ ๋๊ฐ๋ ๊ฒฝ์ฐ, ๋๋ฑํ ์ง๊ธ์ ์ฌ๋์ด ๋๊ฐ๋ ๊ฒ์ด ์ข์
์๋๋ฐฉ์ด ํธํ
์์ฝ์ ์ํ๋ค๋ฉด ํธํ
๊น์ง ์๋ด
ํ๋ฒ์ฏค ํฅํ ์์์ ๋์ ํ๊ฑฐ๋ ๋ช
์น์ง๋ฅผ ์๊ฐํ๋ ๊ฒ๋ ์ข์
์๋์ด ๊ฐ๋ ๋ฌด๋ฆฌํ๊ฒ ์ก์ง ๋ง๊ณ ๊ฐ๋จํ ์ธ์ฌ๋ง๋ก ์๋ณ
์์ ๋ฐ ์ถ์ฐ ์์ ์์ ์ ์ํ๋ ๋ถ๋ชจ์ ๋ง์์์ธ
ํฌ์์๋ ์ฌ๋์ ์ค์ฒํ๊ฒ ๋ค
ํ์ด๋๋ ์ ์๋ช
์ ์ธ๊ฒฉ์ ์ผ๋ก ๋ํ๊ฒ ๋ค
์ถ์ฐ ์ถ์ฐ : ๋ณ์์์ 2-3์ผ ์
์
์ฐํ์กฐ๋ฆฌ : ์ฐํ์กฐ๋ฆฌ์์ ์ด์ฉํ๊ธฐ๋ ํจ
์ถ์ฐํ ์ผ์น ์ผ (21์ผ) ๋์ ์ธ๋ถ์ธ์ ๋ฐฉ๋ฌธ์ ์์
์ฐ๋ฆฌ๋๋ผ๋ ์๋ก๋ถํฐ ์์ด๋ฅผ ๋ณ์ผ๋ฉด ๋๋ฌธ์ ๊ธ์ค์ ์ณค์
์๋ค์ด๋ฉด ๊ณ ์ถ+์ฏ+์์, ๋ธ์ด๋ฉด ์ฏ+์์ ๊ฒฝ์กฐ์ฌ ์์ผ ๊ฒฐํผ ์์ผ ๋ฐฑ์ผ์์น : ์ถ์ ๋ฐฑ์ผ ํ ์์ด์ ์ฐ๋ชจ๋ฅผ ์ถํ, ๋ฐฑ์ค๊ธฐ๋ฅผ ๋๋ ๋จน์ ์ฒซ๋ : ๋ง 1๋
์ด ๋๋ ์ฒซ ํด ์์ผ, ๋์ก์ด ํ๊ฐ : 61์ธ๊ฐ ๋๋ ์์ผ, ์ผ ๊ฐ์๊ฐ ๋์์ด ์ฐ๋ฆฌ๋๋ผ ๋์ด๋ก 60์ธ (๋ง 59๋๋ 58) ์ฐ๋ น๋ณ ์์ผ ๋ช
์นญ 20์ธ (์ฝ๊ด), 30์ธ (์ด๋ฆฝ), 40์ธ (๋ถํน), 50์ธ (์ง์ฒ๋ช
), 60์ธ (์ด์) 61์ธ (ํ๊ฐ), 62์ธ (์ง๊ฐ), 70์ธ (๊ณ ํฌ), 80์ธ (์ฐ์), 88์ธ (๋ฏธ์) 90์ธ (์กธ์), 100์ธ (์์) ์ฑ๋
์ ๋ ๋ง 19์ธ๊ฐ ๋๋ 5์ ์
์งธ์ฃผ ์์์ผ ๋จ์ (๊ด๋ก) : ๋๊ธฐ๋จธ๋ฆฌ ์๋ฅด๊ณ ์ํฌ๋ฅผ ๋ง๋ ํ ๊ฐ์ ์์ฐ๋ ์์ ์ฌ์ (๊ณ๋ก) : ๋จธ๋ฆฌ ์ฌ๋ ค ๋น๋
๋ฅผ ๊ฝ๋ ์์ ์์ํฅ๋ก์ผ๋ก ์ก์ ๋ง์ ํผ๋ก (๊ฒฐํผ์) ์ ํตํผ๋ก์ ์ ์ฐจ ์ํผ : ์๊ฐ๊ฐ ์ค๋งค์ธ์ ํตํด ์๋ก์ ์์ฌ๋ฅผ ์กฐ์
์๋์ด : ์ ๋ถ์ง ๋ง๋น์์ ๋ถ์๊ธฐ๋ฅผ ๋ถ๋์ฐ๋ ๊ณต์ฐ
์ ๋์
์ฅ : ์ ๋์ด ๊ธฐ๋ฌ๊ธฐ ์๋ฒ๊ณผ ํจ๊ป ์ ๋ถ์ง์ผ๋ก ๊ฐ
๊ธฐ๋ฌ๊ธฐ๋ฅผ ์ ๋ฌ ๋ฐ์ ์ ๋์ ์ ๋ถ๋ฅผ ํฅํด ์๋ฅผ ์ฌ๋ฆฌ๊ณ , ๊ธฐ๋ฌ๊ธฐ๋ฅผ ๋์ฒญ์ ์ฌ๋ ค๋์
์ ์๋ก : ์ ๋ถ์ด๋จธ๋๊ป ๊ธฐ๋ฌ๊ธฐ๋ฅผ ๋๋ฆฌ๋ ์์
์ด๋ก์ฒญ : ์ ๋๊ณผ ์ ๋ถ ์
์ฅ
๋ง์ ์ ๋ชธ๊ณผ ๋ง์์ ์ ๊ฐํ๊ฒ ํ๋ค๋ ์๋ฏธ์์ ์์ ์ป์
๊ต๋ฐฐ๋ก (๋ง์ )
์ ๋๊ณผ ์ ๋ถ๋ ์ด๋ก์ฒญ์์ ์ฒ์์ผ๋ก ์ธ์ฌ๋ฅผ ๋๋๋ฉฐ ์๋ก์๊ฒ ์ ์ ๋๊ณผ ์ ๋ถ๋ ๋ฐฑ๋
ํด๋ก๋ฅผ ์์ฝ ํฉ๊ทผ๋ก : ์ ์๊ณผ ํ์ฃผ๋ฐ์ ๊ฐ๊ฐ ์ ์ ๋ถ์ด ๋ง์๋ ์์
ํจ, ํจ์ง์ ๋น, ๋ฉํ, ๋ด์ฑ๋ก ํจ : ๊ฒฐํผ ์ ๋ ์ ๋ ์ง์์ ์ ๋ถ ์ง์ผ๋ก ๋ณด๋ด๋ ์์
ํจ์ง์ ๋น : ํ์ธ์ด๋ ์ฌ๋์ ์ฌ์ ํจ์ ์ง๊ณ ๊ฐ
ํจ ๋ด์ฉ : ์ค๊ณก ์ฃผ๋จธ๋, ์ฒญํ์ฑ๋จ, ํผ์์ง (ํผ์ธ๋ฌธ์), ๋ฌผ๋ชฉ๊ธฐ, ์๋ฌผ ๋ฑ
ํจ์ง์ ๋น ์ผํ์ ์ ๋ถ ์ชฝ ์น์ง๋ค๊ณผ ์ฌํฅ์ ๊ฐ์ง
๋ฉํ : ์ ๋ ์ชฝ์์ ํผ์์ ์ฑ๋จ, ์๋ฌผ์ ํจ์ ๋ด์ ๋ณด๋ด๋ ๊ฒ
๋ด์ฑ๋ก : ํจ์ ๋ฐ๊ธฐ์ํด ์ ๋ถ ์ง์์ ์ค๋นํ๋ ์์
ํ๋์ ๊ฒฐํผ์ ํ๋ฐฑ : ์ ๋ถ๊ฐ ์๋ ์ด๋ฅธ๋ค๊ป ์ฒซ์ธ์ฌ ์ฌ๋ฆฌ๋ ์๋ก
์์ (๋ถ๋ชจ -> ์กฐ๋ถ๋ชจ -> ๋ฐฑ๋ถ๋ด์ธ -> ์๋ถ๋ด์ธ -> ํ์ )
๋ค๋ฌ๋ฆฌ : ํ์ ์๋งค, ์ ๋ ์ ๋ถ์ ์น๊ตฌ๋ค, ์น์ฒ, ํ๋
๊ฒฝ์กฐ์ฌ ์ฅ๋ก ์์์ ์ฅ๋ก์ ๊ตํ์์ ์กฐ์ฉํ ๊ฐ์ด๋ฐ ์์ํ ์งํ ๋ฏธ์ฌ๋ ์๋ฐฐ๊ฐ ๋๋ ํ ๊ณต๋๋ฌ์ง๋ก ์ฅ๋ก ํ๋ ฌ์ด ์์ ํ๋ ฌ์ ์ ๋์๋ ๋ชฉ์ฌ๋์ด๋ ์ ๋ถ๋, ๊ฐ์ฅ ๊ฐ๊น์ด ์ ์กฑ, ์น์ฒ๊ณผ ์ง์ธ ์์ผ๋ก ์ด๋ ๋จ์ ์ ์กฑ์ ๊ฐ์ ์ธ ์ฝ์ฉ ํ์ ๊ด์๋ก ๋์ง๊ณ ์ฌ์๋ค์ ๊ฝ๊ณผ ์์ ๊ฝ๋ค๋ฐ์ ๋์ง ์ฅ๋ก ์ ์ฐจ ์ฅ๋ก ์ฒซ์งธ๋ ์์ข
(์ด๋ช
) : ๋ง์ง๋ง ์จ์ด ๋์ด๊ฐ๋ ๊ฒ
์์ : ๋์ ๊ฐ๊ธฐ๊ณ ํ๋ค๋ฆฌ๋ฅผ ๊ฐ์ง๋ฐํ ํ์ฌ ์ฝ์ ์
์ ์์ผ๋ก ๋ง์์ค๋ค
์ฌ๋ง์ฆ๋ช
์ : ์์ฌ ๋๋ ์, ๊ตฐ ๊ฒ์ฌ๊ด์ด ์ฌ๋งํ์ง 24์๊ฐ ์ด๋ด์ ๋ฐ๊ธํ๋ค
๋ฐ์ : ์ด์์ด ๋ฌ์์ ์ธ๋ถ์ ์๋ฆฌ๊ณ ์๋ก๋ฅผ ์์ํจ์ ๋งํ๋ค
๋ถ๊ณ : ๊ณ ์ธ๊ณผ ์ ์กฑ์ ๊ฐ๊น์ด ์น์ธ์ฒ, ์ง์ธ, ํ์ฌ ๋ฑ์ ๋ถ๊ณ ๋ฅผ ๋ธ๋ค
์ฅ๋ก ๋์งธ๋ ์ผ์ต : ์๋
๋ ์์ด๋ ๊ฑฐ์ฆ๋ก ์์ ์ ์ป๊ธฐ๋ฉฐ(์ผ), ์์๋ฅผ ์
ํ๋ค(์ต)
์
๊ด : ์์ ์ ๊ด์ ๋ชจ์ ๋ค
์์ข ์ค์น : ์์ ์ฌ์ง์ ์ ์ ์์ ๋ชจ์๊ณ ์์ ์ ์์ผ๋ก ์ด๋ถ์ ๋ฐํ๋ค
์ฑ๋ณต : ์์ ๋ ์๋ณต์ ์
๋๋ค
์กฐ๋ฌธ : ์ฑ๋ณต์ด ๋๋๋ฉด ์กฐ๋ฌธ์ ๋ฐ๋๋ค
์กฐ๋ฌธ : ๋์๊ฐ์ ๋ง์์ ๋ณต์ ๋น๊ณ , ์ฌํ์ ์๋กํ๊ธฐ ์ํด ์ฅ๋ก์์ฅ์ ๊ฐ๋ ํ์
์ฅ๋ก ์
์งธ๋ ๋ฐ์ธ : ์๊ตฌ๊ฐ ์ง์ ๋ ๋๋ ์ ์ฐจ์ด๋ฉฐ ๋ฐ์ธ์ ๋ฅผ ์ง๋ธ๋ค
์ด๊ตฌ : ์๊ตฌ๋ฅผ ์ฅ์ง(ํ์ฅ์ง)๊น์ง ์ฅ์์ฐจ๋ ์์ฌ๋ก ์ด๋ฐ
ํ๊ด : ์ฅ์ง์์ ์๊ตฌ(๊ด)์ ๊ด์ค(๊ตฌ๋ฉ์ด)์ ๋ฃ๋๋ค
์ฑ๋ถ(๋ด๋ถ) : ๊ด์ ์์ ํ ๋ฎ์ ํ, ํ์ ์์ ์ฌ๋ ค ์๋๋ฅผ ์
ํ๋ค
์๋ น์ (์ฑ๋ถ์ ) : ๋ฌ์ ์์ ์์ข๋ฅผ ๋ชจ์๊ณ ์ ์ฌ๋ฅผ ์ฌ๋ฆฐ๋ค
์ฅ๋ก ํ ์ ์ ๋ฐ์ฐ์ : ์ง์ผ๋ก ๋์์ ์ํผ์ ์ง์ ๋ง์๋ค์ด๋ ์ ์ฌ
์ผ์ฐ์ : ๋ฌ์์์ ์ฅ๋ก๋ฅผ ์น๋ฅธ์ง 3์ผ์งธ ๋๋ ๋ ์ ๋๋ฆฌ๋ ์ ์ฌ
์ฌ์ญ๊ตฌ์ : ์ฅ๋ก์ผ๋ก๋ถํฐ 49์ผ์งธ ๋๋ ๋ ์ ์ง๋ด๋ ์ ์ฌ
๋ฐฑ์ผ์ : ์ฅ๋ก ํ ๋ฐฑ์ผ์งธ ๋๋ ๋ ์ ์ง๋ด๋ ์ ์ฌ
์กฐ๋ฌธ ์์ ๋ฐฉ๋ช
๋ก ์๋ช
-> ๋ถํฅ๊ณผ ํํ -> ์ฌ๋ฐฐ(ํฐ์ 2) -> ์กฐ๋ฌธ(ํ์ 1) -> ๋ถ์๊ธ ์ ๋ฌ
๊ฐ๊น์ด ์ฌ๋์ด๋ผ๋ฉด ์ฆ์ ์ฐพ์๊ฐ์ ์ ๋์ ๋ป์ ์ ํ๊ณ ์ฅ๋ก ์ ์ฐจ๋ฅผ ๋์์ค
์ผ๋ฐ์ ์ผ๋ก ์ผ์ด ๋๋๊ณ ์ค๋น๊ฐ ๋ ์์ข
์ผ ๋ค์๋ ์กฐ๋ฌธ์ ๊ฐ๋ค
๋ฌธ์ ์ ๋ณต์ฅ ๊ฒ์์, ๋จ์ ํ๊ฒ, ํ๋ คํ ์ก์ธ์๋ฆฌX, ์งํ ๋ฉ์ดํฌ์
X
์กฐ๋ฌธ ์ ์ธ์ฌ๋ง “์ผ๋ง๋ ์์ฌ์ด ํฌ์ ์ง์”, “์๋ก์ ๋ง์์ ์ฌ๋ฆฝ๋๋ค”
์กฐ๋ฌธ์ ์์ ์ ๋ถํฅํ๋ ๋ฐฉ๋ฒ ์ ๊ต์ : ์์ ์ ๋ถํฅ ํ ํฐ์ ์ ๋ ๋ฒํ๊ณ ๋ ํ, ์์ฃผ์ ํ์
๊ธฐ๋
๊ต์ : ๊ฝ์ ์ฌ๋ฆฌ๊ณ (๊ฝ๋ด์ค๋ฆฌ๊ฐ ์กฐ๋ฌธ๊ฐ ์ชฝ์ผ๋ก), ๊ธฐ๋(๋ฌต๋
)์ ํ ํ ์์ฃผ์ ํ์
์กฐ์๊ธ ์ ๋ฌ ๋ฌธ์์ ๋ง์น ํ ๋ฌผ๋ฌ๋์ ๋ถ์ํจ์ ์ง์ ๋ฃ์
์์ฃผ์๊ฒ ์ง์ ๊ฑด๋ค๋ ๊ฒ์ ๊ฒฐ๋ก
๋ดํฌ์ ๋ถ์, ๊ทผ์กฐ, ์กฐ์ ๋ฑ์ด๋ผ ์
๊ฒฝ์กฐ์ฌ ์ ๋ก ์ ๋ก์ ์ข
๋ฅ ๊ธฐ์ ์ฌ ๋์๊ฐ์ ๋ถ๋ชจ๋๊ณผ ์กฐ๋ถ๋ชจ๋์ ๊ธฐ๋ฆฌ๋ ์ ์ฌ ์๋ฏธ : ๋์๊ฐ์ ๋ถ๋ชจ, ์กฐ๋ถ๋ชจ๋์ ์๊ฐํ๋ฉฐ ๋ฟ๋ฆฌ์์๊ณผ ์ ์ฒด์ฑ ์ฐพ๊ธฐ ์๊ฐ : ๋์๊ฐ์ ๋ ์ ์์ (๋ฐค 11์ ~ ์๋ฒฝ 1์)์ ์์ ๊ธฐ๋
๊ต, ์ฒ์ฃผ๊ต๋์ธ : ๊ฐ์กฑ ์๋ฐฐ, ์ถ๋์์ผ๋ก ๋์ ํจ ์ฐจ๋ก ๋ช
์ ๋ ์์นจ์ ์ง๋ ์์ ํ ๋ฒ ์ฌ๋ฆฌ๊ณ , ์ถ๋ฌธ์ ์ฝ์ง ์์ ์ด๋ถ์ ํค์ง ์์ ์์ ์ฌ (์ํฅ) ๊ธฐ์ ๋ฅผ ๋ชจ์์ง ์์ ์กฐ์์ ๋ชจ์๋ ์ ์ฌ ์๋ ฅ 10์์ ์ค์ ์ง๊ณ์์, ๋ฐฉ๊ณ์์์ ๋๊ตฌ๋ ์ฐธ์ฌ ๋ฎ์ ์ผ์ธ์์ ์ง๋ด๋ฉฐ ๊ธฐ์ ์ ์ฐจ์ ๊ฐ์ ์ฐจ๋ก์ ๋ฐ๋ผ๋ดค์ ๋ ์ค๋ฅธ์ชฝ ๋์ชฝ, ์ผ์ชฝ ์์ชฝ
1์ด (์์ , ์, ๋ก๊ตญ, ์๋ฃจ๋ก)
2์ด (์ , ์ก์ , ์์ , ์ , ์ด์ )
3์ด (์กํ, ์ํ, ์ดํ)
4์ด (ํฌ, ๋๋ฌผ, ๊ฐ์ฅ, ๋๋ฐ๊น์น, ์ํ)
5์ด (๊ณผ์ผ, ํ๊ณผ)
์ขํฌ์ฐํ : ์ข์ธก์ ํฌ, ์ฐ์ธก์ ์ํ
์ด๋์ก์ : ๋์ชฝ์ ์ด๋ฅ, ์์ชฝ์ ์ก๋ฅ
๋๋๋ฏธ์ : ์์ ์ ๋จธ๋ฆฌ๋ ๋์ชฝ ๊ผฌ๋ฆฌ๋ ์์ชฝ
์กฐ์จ์ด์ : ๋์ถ, ๋ฐค, ๋ฐฐ, ๊ฐ
์ ์ฌ์์๊ณผ ๊ธฐ๋ณธ ์์ ๋ณต์ญ์, ‘์น’์ ์์ (๊ฝ์น, ์ฐธ์น, ๊ฐ์น)๋ ์ฌ์ฉํ์ง ์๋๋ค ๊ณ ์ถง๊ฐ๋ฃจ, ๋ง๋ ์๋
์ ์ฌ์ฉํ์ง ์๋๋ค ์ง์ค์ ์์๋ ์์ (์์ ๋ด์ ๋๋ ๊ทธ๋ฆ)๊ณผ ์๋ฐ์ ๋จผ์ ์ฌ๋ฆฐ๋ค์ 1์ด ๋ถํฐ ๋๋๋ค ์ค์๋ ๋ก๊ตญ, ์ถ์์๋ ์กํธ, ๊ธฐ์ ์ฌ๋ ๋ฉ(๋ฐฅ)์ ์ฌ๋ฆฐ๋ค ์ํ, ํ, ๋ฉด์ ๊ฑด๋๊ธฐ๋ฅผ ์ฌ์ฉํ๋ค ์ ์ฃผ (์ ์) ํ (๋ํ๋ ํ) ๊ด๊ณ (์๋ฒ์ง : ๊ณ , ์ด๋จธ๋ : ๋น, ํ ์๋ฒ์ง : ์กฐ๊ณ , ํ ๋จธ๋ : ์กฐ๋น) ์ด๋ฆ ์ ์ ์ฒญํ๊ธ์ง๋ฒ ์ฒญํ๊ธ์ง๋ฒ (๊น์๋๋ฒ) ์ฐ๋ฆฌ๋๋ผ ๊ณต์ง์ ๋ฑ์๊ฒ ๋ถ์ ์ฒญํ ๋ฐ ๊ธํ์์๋ฅผ ๊ธ์งํจ ์ ์ฉ : 2๋
์ดํ ์ง์ญ ๋๋ 2000๋ง์ ์ดํ ๊ณผํ๋ฃ 1. ๋ถ์ ์ฒญํ ๊ธ์ง ์ฒญํ๋์ ๊ตญ๊ฐ/์ง๋ฐฉ, ๊ณต์ง ์ ๊ด๋จ์ฒด, ๊ณต๊ณต๊ธฐ๊ด๊ณผ ๊ณต๋ฌด์๊ณผ ๋ฐฐ์ฐ์ ๊ตญ/๊ณต/์ฌ๋ฆผ ํ๊ต ๊ต์ง์, ํ๊ต๋ฒ์ธ์ ์์ง์, ๋ฐฐ์ฐ์ ์ธ๋ก ์ฌ ์ข
์ฌ์์ ๋ฐฐ์ฐ์ ์์ธ ์กฐํญ :๊ณต์ต์ ์ธ ๋ชฉ์ ์ผ๋ก ๊ณ ์ถฉ ๋ฏผ์์ ์ ๋ฌํ๋ ํ์ ๋ฑ ์ ๊ณ ๋ฐฉ๋ฒ ๋ฐ์ ๊ธํ์ ๋๋ ค์ฃผ๊ณ ๊ฑฐ๋ถ ์์ฌ๋ฅผ ํํ ์กฐ์น ์ดํ์๋ ๋ค์ ๋ฐ๋๋ค๋ฉด ์์ ๊ธฐ๊ด์ฅ์๊ฒ ์๋ฉด(์ ์๋ฌธ์ ํฌํจ)์ผ๋ก ์ ๊ณ 2. ๊ธํ์์ ๊ธ์ง ๋์ ๋์ผ์ธ์ผ๋ก๋ถํฐ 1ํ 100๋ง์์ด๊ณผ ๋งค ํ๊ณ์ฐ๋ 300๋ง์ ์ด๊ณผ ๊ธํ ๋ฑ ์์ ์ง๋ฌด์ ๊ด๋ จํ์ฌ 1ํ 100๋ง์ ์ดํ ๊ธํ ๋ฑ ์์ ๋ฐฐ์ฐ์๊ฐ ์์ ๊ธ์ง ๊ธํ ๋ฑ์ ๋ฐ์ ๊ฒฝ์ฐ ์ธ๋ถ ๊ฐ์์ ๋ํต๋ น๋ น์ผ๋ก ์ ํ๋ ๊ธ์ก์ ์ด๊ณผํ๋ ์ฌ๋ก๊ธ ์์ ์์ฌ๋น (3๋ง์), ์ ๋ฌผ (5๋ง์), ๊ฒฝ์กฐ์ฌ๋น (5๋ง์) (๊ฒฐํผ, ์ฅ๋ก๋ง), ๊ธํ (100๋ง์) ์ฒ๋ฒ ๊ณผํ๋ฃ : ๊ธํ์์ (์์๊ธ์ก 2๋ฐฐ ์ด์ 5๋ฐฐ์ดํ), ๊ฐ์ ์ฌ๋ก๊ธ(500๋ง์ ์ดํ) ํ์ฌ ์ฒ๋ฒ : ๋์ผ์ธ์ผ๋ก๋ถํฐ … (3๋
์ดํ ์ง์ญ 3์ฒ๋ง์์ดํ ๋ฒ๊ธ) ์ฐ์ต๋ฌธ์ ๊ณต์ง์ ์๋
๋์์น์ ์ฐธ์ฌํ๋ฉฐ ์ถํ๊ธ์ผ๋ก 5๋ง์์ ์ ๊ณตํ๋ ๊ฒ -> ์๋ฐ (๋์์น๋ ๊ฒฝ์กฐ์ฌ๋น X) ๊ณต์ง์๊ฐ ๊ฒฐํผ์ ํ๊ฐ์ผ๋ก ์ฐธ์ํ์ฌ 3๋ง์ ์ด์์ ์์ฌ๋ฅผ ์ ๊ณต๋ฐ์ ํ์ -> ์๋ฐX (๋ชจ๋ ์ฌ๋๋ค์๊ฒ ๋์ ํ์ผ๋ฏ๋ก) ๊ณต์ง์ ๋ถ์น์ ์ฅ๋ก์์ ๋ถ์๊ธ 5๋ง์๊ณผ ๋ณ๋์ ํํ์ ๋ณด๋ด๋ ๊ฒฝ์ฐ -> ๋ถ์๊ธ + ํํ 10๋ง์ ์ดํ์ผ ๊ฒฝ์ฐ ์๋ฐ X ์ ์๊ถ๋ฒ ์ ์๊ถ ์ ์๊ถ : ์ฐฝ์์๊ฐ ๊ฐ์ง๋ ๊ถ๋ฆฌ
์ ์๋ฌผ : ์ฌ๋์ ์ฌ์์ด๋ ๊ฐ์ ์ ์ผ์ ํ ํ์์ ๋ด์, ์ด๋ฅผ ๋ค๋ฅธ ์ฌ๋๋ค์ด ๋๋ผ๊ณ ๊นจ๋ฌ์ ์ ์๋๋ก ํํํ ๊ฒ.
์ ์๊ถ๋ฒ์ ๋ชฉ์
์ ์์์ ๊ถ๋ฆฌ๋ฅผ ๋ณดํธํ๊ณ ์ ์๋ฌผ์ ๊ณต์ ํ ์ด์ฉ์ ๋๋ชจํจ์ผ๋ก์จ ๋ฌธํ์ฐ์
์ ๋ฐ์ ์ํค๋๋ฐ ์๋ค. ์ ์๊ถ์ ํ์
Copyright ยฉ2022 Apple Inc.
์ ์๊ถ๋ฒ ์ ์ ๋ฐฐ๊ฒฝ 15์ธ๊ธฐ ์ถํ์ธ์์ ์ ๋ฐ๋ช
์ผ๋ก ๋ฌธ์์ ๋๋๋ณต์ ๊ฐ ๊ฐ๋ฅํด์ง
์ฐ๋ฆฌ๋๋ผ์ ์ ์๊ถ๋ฒ
1957๋
์ ์๊ถ๋ฒ ์ ์ (์ผ๋ณธ ์ ์๊ถ๋ฒ ์ ์ ์
1987๋
๊ตญ์ ์๋์ ๋น๋์ผ๋ก ์ ์๊ถ๋ฒ ๊ฐ์ 1996๋
๋ฒ ๋ฅธ ํ์ฝ ๊ฐ์
๋ฌดํ๋ ๋ฐฉ์ ์ฃผ์ (์ฐ๋ฆฌ๋๋ผ์ ์ ์๊ถ๋ฒ)
=> ์ ์๋ฌผ์ ์ฐฝ์ํ๋ ๋์์ ์๋์ผ๋ก ๋ฐ์ํ๋ ๊ฒ์ผ๋ก ๋ด => ์ ์๊ถ์ ๋ฐ์์ ์ด๋ ํ ์ ์ฐจ๋ ํ๋๋ฐฉ์์ ์ํ์ง ์๋๋ค๋ ๊ฒ์ ์๋ฏธ ์กฐ๊ฑด : ์์ ๋ง์ ํํ ๋ฐฉ์์ผ๋ก ๋
์์ ์ผ๋ก ํํํ ๊ฒ ๋ฐฉ์์ฃผ์ (์ฐ๋ฆฌ๋๋ผ์ ํนํ๊ถ)
=> ๊ธฐ์ ๊ณต๊ฐ์ ๋๊ฐ๋ก ๋
์ ๊ถ์ ๋ถ์ฌํจ์ผ๋ก์จ ๋ฐ๋ช
์์์ ๊ณ ์ทจํจ ์กฐ๊ฑด : ์ด๋ฏธ ์๋ ค์ง ๊ธฐ์ ์ด ์๋์ด์ผํ๊ณ ์ฐ์
์ ์ด์ฉ ๊ฐ๋ฅ ํ ๊ธฐ์ ์ผ ๊ฒ ๋ฒ์ ๋ณดํธ๋ฅผ ๋ฐ๋ ์ ์๋ฌผ์ด ๋๋ ์๊ฑด
๋
์ฐฝ์ฑ์ด ์์ด์ผ ํ๋ค ๋ค๋ฅธ ์ฌ๋์ด ๋๊ปด์ ์ ์ ์์ ์ ๋๋ก ์ธ๋ถ์ ํํ๋์ด์ผ ํ๋ค ์ ์ ์ธ๊ฒฉ๊ถ
์ ์์์ ๋ช
์์ ์ธ๊ฒฉ์ ์ด์ต์ ๋ณดํธํ๊ธฐ ์ํ ๊ถ๋ฆฌ ๊ณตํ๊ถ, ์ฑ๋ช
ํ์๊ถ, ๋์ผ์ฑ ์ ์ง๊ถ (๋จํธ์์ค -> ๋งํ ์ ์ํ๋ ๊ฒฝ์ฐ) ์ ์์ฌ์ฐ๊ถ
=> ์ ์๋ฌผ์ ์ด๋ค ๋ฐฉ๋ฒ์ผ๋ก ์ด์ฉํ๋๋์ ๋ฐ๋ฅธ ๊ถ๋ฆฌ ๋ณต์ ๊ถ : ๋ณต์ฌ, ์ธ์, ์ฌ์ง, ๋
น์, ๋
นํ ๋ฑ์ ๋ฐฉ๋ฒ์ผ๋ก ๋ค์ ์ ์ํ๋ ๊ฒ ๊ณต์ฐ๊ถ, ๊ณต์ค์ก์ ๊ถ, ์ ์๊ถ, ๋ฐฐํฌ๊ถ, ๋์ฌ๊ถ, 2์ฐจ์ ์ ์๋ฌผ ์์ฑ๊ถ ์ ์์ธ์ ๊ถ
์ ์๋ฌผ์ ์ ๋ฌ์๋ก์์ ์ญํ ์ ํ๋ ์์๊ฒ ๋ถ์ฌ๋๋ ๊ถ๋ฆฌ ์ง์ฅ๋งค๋ ํธ์นญ ์๊ธ์ : ์ฑ์จ+์ง์+๋, ์ง์+๋ ๋๊ธ์ ์ฑ์จ+์ง์, ์ฑ์จ+์ง์+๋ (์ ์นํ๊ฑฐ๋ ๋์ด๊ฐ ๋ง์ ๋) ์ฑ๋ช
+์จ (์ฐํ์ด๊ฑฐ๋ ์ง๊ธ์ด ์์ ๋) ํ๊ธ์ : ์ฑ๋ช
+์จ, ์ ๋ฐฐ๋(์ฐ์ฅ์) ์ง์ฅ ์์ฌ์ ๊ฐ์กฑ : ๋จํธ(์ฑ+์ ์๋), ๋ถ์ธ(์ฌ๋ชจ๋), ์๋
(์ฑ๋ช
+์จ) ๋๋ฃ์ ๊ฐ์กฑ : ๋จํธ (๋ถ๊ตฐ, ๋ฐ๊นฅ์ ์๋), ์๋ด(๋ถ์ธ, ์์ฃผ์ธ) ์ธ์ฌ๋ง ์์์ฌ๋์๊ฒ : ๊ณ ์ํ์ญ์์คX, ์๊ณ ํ์ญ์์คX ๋ฐ๋ฅด๊ฒ ์๋ ์์ธ ์์ ์ผํธ์ผ๋ก ๋ค์ด๊ฐ์ ๊น์ํ ์๋๋ค ํ๋ฆฌ์ ๊ฐ์ดํด๊ณ ๋ฑ๋ฐ์ด์ ๊ธฐ๋๋ค, ๋ค๋ฆฌ๋ฅผ ๊ผฌ์ง ์๊ณ ๋ฌด๋ฆ์ ๋ถ์ฌ ์๋๋ค ์ง์ ๋ฐ์ ๋ 5W 2H (When Where Who What Why, How How much) ๊ด์ 20๋ ์์ฐํ์ฑ ์ข
์ฃ๋ ๋ชจ์ผ๊ธฐ ์ข
์ฃ๋ : ๋ณธ๊ฒฉ์ ์ธ ํฌ์๋ฅผ ์์ํ๋๋ฐ ํ์ํ ์ด๊ธฐ์๊ธ
๊ฐ์์ ์ธ ๋ชฉํ๋ฅผ ์ธ์ฐ์ (ex ์ด๋ฒ๋
์ 500๋ง์์ ๋ชจ์ผ์)
๊ธ์ก : ๊ธฐ์กด ์ ์ถ๊ธ์ก์ ์ ์ธํ ๋๋จธ์ง ๊ธ์ก
๊ธฐ๊ฐ : 1~2๋
์ ๋จ๊ธฐ๊ณํ, ์์ ํ ์ ๊ธ์ด๋ ์ฑ๊ถํ ํ๋
๊ธ์ต ์ํ ์ ํ
์ฃผํ์๊ธ : ์ฃผํ์ฒญ์ฝ์ ์ถ, ๋
ธํ์๊ธ : ์ฐ๊ธ์ ์ถ
๊ฒฐํผ์๊ธ : ํผํฉํ ํ๋, ๋น์๊ธ : CMA์ํ, ์ข
์ฃ๋ : ์ ๊ธ/์ฑ๊ถํ ํ๋
์ฃผํ์ฒญ์ฝ์ ์ถ
์๋ก ์ง์ ์ํํธ๋ฅผ ๋ถ์ ๋ฐ์ผ๋ ค๋ ์ฌ๋๋ค์ด ๊ฐ์ค
1์ธ 1๊ณ์ข, ์ฃผํ ์์ ์ฌ๋ถ์ ๊ด๊ณ์์ด ๊ฐ์
๊ฐ๋ฅ
๊ณต๊ณต๋ถ์ (์ฃผํ๊ณต์ฌ) : ์ ๊ธํํ (2~10)
์ฒญ์ฝ๊ธ์ก์ด ํด์๋ก ์ ๋ฆฌ ๋ฏผ๊ฐ๋ถ์ (๋ฏผ๊ฐ๊ฑด์คํ์ฌ) : ๊ฐ์ ์ , ์ถ์ฒจ์
๋ฌด์ฃผํ ๊ธฐ๊ฐ ๊ธธ์๋ก, ๋ถ์๊ฐ์กฑ ๋ง์์๋ก ์ ๋ฆฌ ๊ตญ๋ฏผ ์ฐ๊ธ๋ณดํ
์ฃฝ์๋ ๊น์ง ์ง๊ธ๋๋ ์ฐ๊ธ์ํ, ์๋์ด ์๋ ๊ตญ๋ฏผ์ด๋ผ๋ฉด ์๋ฌด ๊ฐ์
์ฐ๊ธ์ง๊ธ ์์ (61~65์ธ) ๋ณดํ๋ฃ๋ ์๋์ 9% ์ง์ฅ์ธ์ ์ ๋ฐ์ ๊ณ ์ฉ์ฃผ๊ฐ ๋ถ๋ด ๊ฐ์ธ์ฌ์
์๋ ์ฃผ๋ถ๋ ์ ์ก์ ์์ ์ด ๋ถ๋ด ํด์ง ์ฐ๊ธ ์ ๋
ํด์ง๊ธ : ๊ทผ๋ฌด๊ธฐ๊ฐ 1๋
์ ์ฑ์ธ ๋๋ง๋ค ํ ๋ฌ์น์ ์๊ธ์ ๋ชจ์๋จ๋ค๊ฐ ํ๋ฒ์ ์ฃผ๋ ๋ ์ผ์๊ธ/์ฐ๊ธ์ผ๋ก ๋๋์ด์ง๋ค ํด์ง๊ธ ์ ๋ (ํ์ฌ๊ฐ ํ์ฐ -> ๋ชป ๋๋ ค๋ฐ์)์ ๊ฐ์ ํ์ฌ ํด์ง์ฐ๊ธ ์ ๋ DBํ (ํ์ฌ๊ฐ ์ด์ฉ์ง์) : ์ํ ์๊ธ ๋ฐฉ์, ๊ทผ๋ก์๊ฐ ๋ฏธ๋ฆฌ ๊ธ์ก์ ์ ์ ์๋ค. DCํ (๊ทผ๋ก์๊ฐ ์ด์ฉ์ง์) : ์ฃผ๋ก ์ฃผ์์ด๋ ์ฑ๊ถ ํฌ์, ๊ธ์ก์ ์ ์ ์๋ค ์ฃผํ ์ฐ๊ธ ์ ๋ (์ญ๋ชจ๊ธฐ์ง๋ก )
๋ง 55์ธ ์ด์์ ๊ณ ๋ น์๊ฐ ๊ธ์ต๊ธฐ๊ด์ ์์ ์ด ์ด๊ณ ์๋ ์ฃผํ์ ๋ด๋ณด๋ก ์ ๊ณตํ ๋ค, ๋งค๋ฌ ๊ณ ์ ์ ์ธ ์ํ์๊ธ์ ์ฐ๊ธ์์ผ๋ก ๋ฐ๋ ์ฅ๊ธฐ์ฃผํ์ ๋น๋์ถ ๊ธ์ต์ ๋ณด : 20๋์ ๊ธ์ต์ง์์ ์๋ ๊ฒ์ ์ค์ํ๋ค
์ฌ๋ฌด๋ชฉํ ์ค์ ๋ฐฉ๋ฒ ํ๋ช
ํ ์๋น ์ํ ๊ฑด์ ํ ๊ฐ์น๊ด์ ๊ฐ์ง๊ณ , ์์ฐ ์ํ์ ์ค์ฒํ๋ ์ํ
์์ฐ ์ํ ํฌ์์ฑ์ ์์น : ์ฐ๋ฆฌ๊ฐ ๊ฐ์ง ์ฌํ๋ ๋ฌดํํ์ง ์๋ค ์๋น๊ฐ์น๊ด : ์๋น์ ์ฐ์ ์์์์ ์ด๋ค ํ๋ชฉ์ ์ฐ์ ์ํ ๊ฒ์ธ๊ฐ์ ๋ํ ๊ฐ์์ ์ ๋
๊ฐ์ฒ๋ถ ์๋ = ์ด ์๋ - ๋น์๋น์ง์ถ (์ธ๊ธ, ๊ตญ๋ฏผ์ฐ๊ธ, ๊ฑด๊ฐ๋ณดํ) ์์ฐ : ์ผ์ ๊ธฐ๊ฐ ๋์์ ๊ธฐ๋ ์์
์ ๊ธฐ์ดํ ์ง์ถ ๊ณํ ์์ฐ ์ํ์ ์ฅ์ ์์ ์ด ์ถ๊ตฌํด์ผํ ์ฌ๋ฌด์๊ตฌ๋ฅผ ๊ตฌ์ฒด์ ์ผ๋ก ์ ์ ์๋ค. ์์ ์ ์์
๊ธ์ก, ์ง์ถ๊ธ์ก ์ฌ๋ฌด์ํ๋ฅผ ํ์
ํ ์ ์๋ค. ์๋์ ๋๋ฆด ๋ฐฉ์์ด๋ ์๋น์ ์ด๋ค ๋ถ๋ถ์ ์ค์ฌ์ผ ํ๋์ง๋ฅผ ์ ์ ์๋ค. ๊ฒฐ๊ณผ๋ฅผ ํ๊ฐํจ์ผ๋ก์จ ๋ฌธ์ ์ ์ ์ฐพ๊ณ ๊ฐ์ ํด ๋๊ฐ ์ ์๋ค. ์ฌ๋ฌด ๋ชฉํ์ ์๊ฑด ํ์ค์ฑ ์๋ ๋ชฉํ ์ค์ ๊ตฌ์ฒด์ ์ด๋ฉด์ ์ธก์ ๊ฐ๋ฅํ ๋ชฉํ ์ค์ ๋ธ๋ ์ปจ์๋จธ ์๋น์ ๊ถ์ต ์๋น์๋ณดํธ๋ฒ์ ์ ์ ๋ ์ด๋๋ก 40๋
๊ฐ ์๋น์ ๊ถ์ต์ ์ฆ์ง์ํด ๋ธ๋์ปจ์๋จธ ๊ธฐ์
๋ฑ์ ์๋๋ก ๋ถ๋นํ ์ด์ต์ ์ทจํ๊ณ ์ ์ ํ์ ๊ตฌ๋งคํ ํ ๊ณ ์์ ์ผ๋ก ์
์ฑ ๋ฏผ์์ ์์ต์ ์ผ๋ก ์ ๊ธฐํ๋ ์
๋น๋งค๋ ์ปจ์๋จธ ๊ทผ๋ก์์๊ฒ ‘๊ฐ์ง’ํ๋ ์๋น์
๋ธ๋์ปจ์๋จธ๋ฅผ ํฌํจ
=> ‘๊ฐ์ง’์ ํผํด๋ฅผ ๋นํ๋ ๊ทผ๋ก์๊ฐ ๋ง์์ง์ ๋ฐ๋ผ ‘์ฐ์
์์ ๋ณด๊ฑด์ ’ ๊ฐ์
์ค๋ฆฌ์ ์๋น ์๋น์๊ฐ ๋ฌผ๊ฑด์ ๊ตฌ์
ํ ๋, ๊ฐ๊ฒฉ๊ณผ ํ์ง ๋ฟ๋ง ์๋๋ผ ์ฌํ์ ํ๊ฒฝ์ ๋ฏธ์น๋ ์ํฅ์ ๊ณ ๋ คํด์ผ ํ๋ค๋ ๊ฒ ์นํ๊ฒฝ ์๋น ์๊ฑฐ๋ ์๋น์ค๋ฆฌ ์ฌ์
์์ ๊ฑฐ๋ํ ๋ ์ ํด์ง ๊ณ์ฝ์ ์๋ฌด๋ฅผ ์งํค๋ ์ผ ๋ฐ์ด์ฝง : ์ค๋ฆฌ์ ์ผ๋ก ๋ฐ๋์งํ ์ ํ์ ๊ตฌ์
ํ๋ ๊ตฌ๋งค์ด๋ ๋ก์ปฌํธ๋ ์๋น ๊ณต์ ๋ฌด์ญ ์ํ ๊ตฌ๋งค ๊ธฐ๋ถ์ ๋๋ ํฌ๋ผ์ฐ๋ ํ๋ฉ ์จ๋ผ์ธ์ ํตํด ๋ค์์ ์์กํฌ์์๋ก๋ถํฐ ์๊ธ์ ์กฐ๋ฌํ๋ ๊ฒ ์ข
๋ฅ ๋ฆฌ์๋ํ : ์ ํ์ ์์ฐ์๊ฐ ๋ง๋ค์ด๋ด๋ฉด ์ผ๋ฐ์ธ์ด ์ ์ฃผ๋ฌธํด์ ๊ตฌ๋งคํ๋ ๊ฒฝ์ฐ ๊ธฐ๋ถํ : ๊ณต์ต์ ์ธ ํ๋ก์ ํธ๋ฅผ ์งํํ๊ธฐ ์ํด์ ๋ชจ์ผ๋ ๊ฒฝ์ฐ ๋์ถํ : ๊ฐ์ธ๋ค ์ฌ์ด์์ P2P ๋์ถ์ด ์ด๋ฃจ์ด์ง๊ณ , ๋ฆฌ์๋๋ก ์ด์๊ฐ ์ ๊ณต ํฌ์ํ : ํฌ์์๊ธ์ ์ง์ํ๊ณ ์ฃผ์ ๋ฐ ์ฑ๊ถ ๋ฑ์ ๋ณด์์ ๋ฐ์ ํ๋ฉ ๊ธฐํ ๋ด์ ๋ชฉํ๊ธ์ก์ ๋ชจ์ผ์ง ๋ชปํ๋ฉด ์๊ธ์ ๋ค์ ๋๋๋ ค ์ค๋ค ๋ฐ์ ๋ฐฐ๊ฒฝ ์ค๊ฐ ํ๋ซํผ๋ฑ์ฅ, SNSํ์์คํ, ๋์์ ๊ธฐ์
๊ธ์ต, ํฌ๋ผ์ฐ๋ํ๋ฉ๋ฒ ์ฌํ์ ๊ธฐ์
์ฌํ์ ๊ธฐ์
์๋ฆฌ ๊ธฐ์
๊ณผ ๋น์๋ฆฌ๊ธฐ์
์ ์ค๊ฐ ํํ
์ฌํ์ ๋ชฉ์ ์ ์ฐ์ ์ ์ผ๋ก ์ถ๊ตฌํ๋ฉด์, ์ฌํ์ ์๋น์ค์ ์์ฐํ๋งค ๋ฑ ์์
ํ๋์ ์ํํ๋ ๊ธฐ์
๊ณต๊ณต์ฑ๊ณผ ์์ต์ฑ
(๊ณต๊ณต์ฑ) ์์๋ด์ฌ <- NGO <- ์ฌํ์ ๊ธฐ์
-> ํ๋์กฐํฉ -> ์ผ๋ฐ๊ธฐ์
(์์ต์ฑ)
์ฑ๊ณต๋ฐฉ์
์๋ฆฌ๊ธฐ์
๊ณผ ์ฌํ์ ๊ธฐ์
๊ฐ์ ํํธ๋์ญ์ ๋ชจ์ํ ๊ฒ ์ข
๋ฅ
์ผ์๋ฆฌ์ ๊ณตํ : ์ทจ์ฝ๊ณ์ธต์๊ฒ ์ผ์๋ฆฌ๋ฅผ 30% ์ด์ ์ ๊ณตํ๋ ๊ฒฝ์ฐ ์ฌํ์๋น์ค์ ๊ณตํ : ์ทจ์ฝ๊ณ์ธต์ 30% ์ด์์๊ฒ ์ฌํ์๋น์ค๋ฅผ ์ํํ ๊ฒฝ์ฐ ํผํฉํ : ์ทจ์ฝ๊ณ์ธต์๊ฒ ์ผ์๋ฆฌ๋ ์ฌํ ์๋น์ค๋ฅผ ๊ฐ์ด ์ ๊ณตํ๋ ๊ฒฝ์ฐ ์ง์ญ์ฌํ๊ณตํํ : ๋ง์์ ๊ฒฝ์ ์ , ์ฌํ์ , ๋ฌธํ์ ํ์ฑํ์ ๊ณตํํ๋ ๊ฒฝ์ฐ ๊ธฐํํ : ์ฐฝ์์ , ํ์ ์ ๋ฐฉ์์ผ๋ก ์ฌํ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ณ ์ ๋
ธ๋ ฅํ ๊ฒฝ์ฐ ์์
๋ฒค์ฒ ๊ฒฝ์ฐ๋ํ
์ฌํ์ ๊ธฐ์
์ ์ฐฝ์
์์ด๋์ด๋ฅผ ๋ฐ๊ตดํ๊ณ ์ฌ์
ํ๋ฅผ ์ง์ํ๋ ๋ํ ์ปค๋ฎค๋์ผ์ด์
๋งค๋ ๋ ์ ๋ฌ๋ฒ (I-Message) ๋๋ฅผ ์ฃผ์ด๋ก ์์ ์ ๊ฐ์ ์ด๋ ์๊ฐ์ ํํํ๋ ์ ๋ฌ๋ฒ
๋ํ์ ํ๋ ฅ์ฑ ๋์์ ์ฌ๊ณ : ์นจ๋ฌต์ ๊ธ์ด๋ค, ์ผ๋ฐฉํตํํ ์์์ ์ฌ๊ณ : ๋ํ๋ ์๋ฐฉํฅ, ๋ฆฌ์ก์
์ค์ ๋จ์ฑ์ ๊ฒฐํผ ํ ๊ฐ์กฑ๊ฐ์ ํธ์นญ ๊ตฌ๋ถ ํธ์นญ (์ง์ ) ์ง์นญ(3์) ์๋ด์ ์๋ฒ์ง ์ฅ์ธ์ด๋ฅธ, ์๋ฒ๋ ์ฅ์ธ์ด๋ฅธ, OO ์ธํ ์๋ฒ์ง ์๋ด์ ์ด๋จธ๋ ์ฅ๋ชจ๋, ์ด๋จธ๋ ์ฅ๋ชจ๋, OO ์ธํ ๋จธ๋ ์๋ด ์ฌ๋ณด, OO์๋ง, ์์, ๋น์ ์ง์ฌ๋, ์์ฌ๋, OO์๋ง, ์๋ด ์๋ด์ ์ค๋น ํ๋ ์ข๋ ์๋ด์ ๋จ๋์ ์ฒ๋จ, ์๋ค ์ข๋ ์๋ด์ ์ธ๋ ์ฒํ ์ข๋ ์๋ด์ ์ฌ๋์ ์ฒ์ ์ข๋ ๋ธ์ ๋จํธ O์๋ฐฉ ์ฐ๋ฆฌ ์ฌ์ ์ฌ์ฑ์ ๊ฒฐํผ ํ ๊ฐ์กฑ๊ฐ์ ํธ์นญ ๊ตฌ๋ถ ํธ์นญ (์ง์ ) ์ง์นญ(3์) ๋จํธ์ ์๋ฒ์ง ์๋ฒ๋ ์์๋ฒ์ง, OO ํ ์๋ฒ์ง ๋จํธ์ ์ด๋จธ๋ ์ด๋จธ๋ ์์ด๋จธ๋, OO ํ ๋จธ๋ ๋จํธ ์ฌ๋ณด, OO์๋น , ๋น์ , ์๊ฐ ๋จํธ, ์๋ฒ, ๊ทธ ์ด ๋จํธ์ ํ ์์ฃผ๋ฒ๋ ์์ฃผ๋ฒ๋, ์์ ๋จํธ์ ๋จ๋์ ๋๋ จ๋(๊ธฐํผ), ์๋ฐฉ๋(๊ธฐํผ) ์๋์ ๋จํธ์ ๋๋ ํ๋ ์๋์ด ๋จํธ์ ์ฌ๋์ ์๊ฐ์จ ์๋์ด ์๋ค์ ์๋ด ์๊ฐ, ์์๊ฐ ์ฐ๋ฆฌ ๋ฉฐ๋์ ํ ๋ก ์ ๊ฒฝ์ฒญ์์ ๋งค๋ SMART ๊ฒฝ์ฒญ๋ฒ Subject (ํ ๋ก ์ ์ฃผ์ ์๊ฐ) Materials (์ธ์ฉํ๋ ์๋ฃ์ ์ถ์ฒ ์ ์) Assertion (์ฃผ์ฅ์ด ๋ฌด์์ธ์ง ํ์
) Reaction (๋ฐ์[๋์/๋ฐ๋]์ ์ด๋ป๊ฒ ํ ์ง ์๊ฐ) Trademark (๋ค๋ฅธ ์ฌ๋์ ์ฃผ์ฅ๊ณผ ๊ตฌ๋ณ๋๋ ํน์์ด ๋ฌด์์ธ์ง ์ฐพ์๋ณธ๋ค) ํต์ ๋งค๋ (ํธ์ง) ์๋ถ ํธ์ง : ๊ฒฉ์์ ์ฐจ๋ฆด ํ์ ์์ ๊ฐ์ฌ ํธ์ง : ํ์ฌ ํ 2~3์ผ ์ด๋ด ์ ์ํ๊ฒ ๋ณด๋ผ ๊ฒ ์ด์ฒญํธ์ง : 2์ฃผ~4์ฃผ ์ ์ ์กํ์์น์ ๋ง์ถ์ด ๋ณด๋ผ ๊ฒ ์๋กํธ์ง : ํ ๊น ๋ง๊น ๊ณ ๋ฏผ๋๋ฉด ์ฐ์, ์ง์ ์ฑ๊ณผ ๋ฐ๋ปํ ๋ง์์ ํํํ ๊ฒ ์์ฃผ๋งค๋(1) ์ ํฌ๋์ฃผ 12-13๋ ์ก๋ฅ์๋ฆฌ์ ์ ํฉ
๋ฐฑํฌ๋์ฃผ 10-13๋, ์์ ์๋ฆฌ์ ์ ํฉ
๋ก์ 6-8๋, ์์ , ํด๋ฌผ๋ฅ, ๋ญ๊ณ ๊ธฐ์ ์ด์ธ๋ฆผ
์์ด์ค์์ธ ๋น๋๊ฐ ๋๊ณ ๊ณผ์ผ ํฅ์ด ์งํจ
๋์ ํธ ์์ธ 18๋ ์ ํ
์คํํด๋ง ์์ธ 10-14๋, ํํฐ์ฉ
ํฌ๋์ฃผ ๋ผ๋ฒจ ์์ธ์ด๋ฆ ์์ฐ์ง ์์ด๋๋ฆฌ(์์กฐ์ฅ) ์ด๋ฆ ์์กฐ์ฅ ์ค๋ฆฝ๋
๋ ๋น๋ ์์ธ์ ๋น๋ ์ดํ๋ฆฌ์ : (dry) <- ์ธ์ฝ <- ์๋ณด์นดํ <-> ์๋ง๋น๋ -> ๋์ฒด -> (sweet) ํ๋์ค : (dry) <- ๋ธ๋ฆฌ <- ์ธํฌ <-> ๋์ค -> (๋ฏ์๋ , ๋ฆฌํ๋ฅด) -> (sweet) ์์ธ์์ ์ข
๋ฅ (์ฌ์ง์๋ฃ) ๋ณด๋ฅด๋ (๋ ๋์์ธ ์), ๋ถ๋ฅด๊ณ ๋ด(๋ ๋์์ธ ์) ํ์ดํธ์์ธ ์, ์คํํด๋ง ์์ธ ์ (์ดํ์ธ ์) ์์ธ ๋ฐ๋ฅด๋ ๋ฐฉ๋ฒ ๋ผ๋ฒจ์ ๊ฐ๋ฆฌ์ง ์๊ฒ ์ก๋๋ค ๋ ๋์์ธ์ ์์ 1/3 ์ฑ์, ์คํํด๋ฆฌ์์ธ์ 2/3 ์ฑ์ ์์ธ์ ์์ด ์ ์ด์ง๋ฉด ์์ธ์ ์จ๋๊ฐ ์ฌ๋ผ๊ฐ์ ๋ง์ด ๋ํจ, ์๋๋ฐฉ ์ํฅ์ ๋ฌผ์ด๋ณด๊ณ ์ฒจ์ ์์ธ ๋ฐ๋ ๋ฐฉ๋ฒ ์์ ํ
์ด๋ธ์ ๋์ ์ฑ ์์ ๋ฐ ๋ถ๋ถ์ ์์ ๋ ์ฑ ๋ฐ๋๋ค ์ค์๋ง : ์์ ์คํ
์ ์ก๊ณ ํ์ชฝ ๋ฐฉํฅ์ผ๋ก ํ์ -> ํฅ์ ํ๋ถํ๊ฒ ์์ฃผ๋งค๋(2) ํํฐ์์ ์์ธ์ ๋ฐ๋ฅด๋ ๋งค๋ ๋จ์ฑ ํธ์คํธ๊ฐ ๋จผ์ ํ
์ด์คํ
-> ์์์ ์์ ์ฌ์ฑ -> ์๊ณ๋ฐฉํฅ ์ฌ์ฑ๋ง -> ๋จ์ฑ -> ์ฃผ์ธ ์์ผ๋ก ๋ฐ๋ฆ ๋จ์ ์ ๋ณด๊ด ๋ฐฉ๋ฒ ์ผ๋ฐ์ : ์๋ํ ๊ณณ์ ๋ณ์ ๋์ด์ ์ ๋ฌธ์ : ์์ธ๋ณ ์์ ๊ณต๊ธฐ๋ฅผ ์ต์ํ ์์ฃผ์ ์ข
๋ฅ ๋ธ๋๋ : ์ฆ๋ฅํ ํฌ๋์ฃผ, 40~42๋ ์์คํค : ๊ณก์ฃผ๋ฅผ ์ฆ๋ฅํ ์ ๋ณด๋์นด : 3 ็ก (๋ฌด์, ๋ฌด์ทจ, ๋ฌด๋ฏธ), ์์ฃผ ์ฐจ๊ฒํ์ฌ ํ๋ฒ์ ๋ง์ฌ ๋ฐํฌ๋ผ : ์ฉ์ค๋์ ์ฆ์ ์คํ ๋ฃ๊ณ ๋ฐํจ, 40๋~60๋ ์ค๊ตญ ์๋์ ์ด์ฒญํ ๊ฒฝ์ฐ ๋ง์ด ๋ง์๋๋ก ๊ถํจ, ์ฒจ์๋ฌธํ ์ผ๋ณธ ์ด์์นด์ผ, ์๊ธฐ ์ฃผ๋๋งํผ ๋ง์ฌ, ์ฒจ์ ๋ฐฉ์, ํ์์ผ๋ก ๋ฐ๋ฅด๊ณ ๋ฐ์, ์๋ฆฌ๊นก (๊ฐ์ ๋ถ๋ด) ํ๋์ค ์์ ์ฃผ๋ฅผ ์์ ์์ ๋ง์ฌ ๋ฐฑํฌ๋์ฃผ, ์ํธ๋ (์ ์ฑ์๋ฆฌ) ์ ๊ณต ์ ํฌ๋์ฃผ, ๋ณธ์์ฌ ์ ๊ณต ์ ์ข
๋ฅ๋ง๋ค ์์ด ๋ค๋ฆ ์์ฌ ๋๋๋ฉด ์ปคํผ, ์ฝ๋ ๋
์ผ ์์ฃผ๊ฐ ์ํ์ ์ผ๋ถ, ๋ค๋ฅธ ์ฌ๋์๊ฒ ์ ์ ๊ถํ์ง ์์ ์๊ตญ ์ค์ฝํ๋๋ ์์คํค(์ค์นด์น) ์ ๋ช
๋ฏธ๊ตญ ์ฅ์ธ์์ ์์ฃผ ๊ธ์ง, ์ผ์์ผ์๋ ์ ์ ํ์ง ์์ ๋ฌ์์ ๋ณด๋์นด๋ฅผ ์ข์ํจ ๋ณตํต->(๋ณด๋์นด+์๊ธ), ๊ฐ๊ธฐ->(๋ณด๋์นด+ํ์ถ), ์ปจ๋์
์ ํ(๋ณด๋์นด+ ๋ง๋ ๋๋ ์ํ) ํก์ฐ๋งค๋ ๋ด๋ฐฐ ์ ์ ํด๋ฌผ์ง ์ผ์ฐํํ์ : ํค๋ชจ๊ธ๋ก๋น๊ณผ ๊ฒฐํฉํ์ฌ, ์ฐ์๊ณต๊ธ์ ์ ํ์ํด -> ์ฐ์์ผํฌ ๋์ฝํด : ๋ํ๋ฏผ ๋ถ๋น -> ์์ ๊ฐ, ๊ธด์ฅ๊ฐ ํด์ ํ๋ฅด : ํํผ์ธํฌ ๋ฑ์ ํ๊ดดํ๊ฑฐ๋ ์ผ์ฆ์ ์ผ์ผํด ํ๊ตญ ์์ ํน์ง ์ฃผ์๊ณผ ๋ถ์์ ๊ตฌ๋ถ (์ฃผ์ : ๋ฐฅ) ๊ณก๋ฅ์ ๋ค์ํ ์กฐ๋ฆฌ๋ฒ ๋ฐํจ ๋ฐ ์ ์ฅ ์ํ์ ๋ฐ๋ฌ ์ฐ๋ฆฌ๋๋ผ 5๋ ๋ฐํจ์ํ : ์ฅ๋ฅ, ๊น์น, ์์ด๋ฅ, ํด๋ฅ, ์ฃผ๋ฅ ์ ์(๋ช
์ ์์)๊ณผ ์์(๊ณ์ ์์) ์๊ทน์ ์ธ ๋ง : ๋ถ์์ ๊ณ ์ถง๊ฐ๋ฃจ, ๋ง๋, ์๊ฐ ๋ฑ ์ฌ์ฉ ๊ณต๊ฐ์ ๊ฐํ ์์ฐจ๋ฆผ : ์ํ์์ ํ๋ฒ์ ์ ๋ถ ์ฐจ๋ ค๋ ๊น์น์ ๋ฐํจ ์๋ฆฌ ๋ฌด, ๋ฐฐ์ถ์ ํจ์๊ฐ ๋น๊ณผ ์๋ฏธ๋
ธ์ฐ์ ๋ง๋ฌ ์ ์ฐ๊ท (๋ฏธ์๋ฌผ์ ํ ์ข
๋ฅ) ์๊น ์ ์ฐ๊ณผ ์๊ธ์ด ๋ง๋ ์ ์ฐ์ ์์ฑ ์ ์ฐ๊ท ์ด ๋ค๋ฅธ ๋ฏธ์๋ฌผ์ ์ ๊ฑฐ ๊น์น๋ ์ ์ฐ์ ์ํด ๋ฐํจ๋จ ์ฐ๋ฆฌ๋๋ผ ์ง์ญ๋ณ ๊น์น ์ข
๋ฅ ์ง์ญ ๊น์น ์ข
๋ฅ ํน์ง ํ์๋ ๋ฐฑ๊น์น, ๊ฐ์ง๊น์น ์๊ณ ๊ธฐ ์ก์ ์ฌ์ฉ ๊ฐ์๋ ์ค์ง์ด๊น์น, ๋๋๊น์น ์ฑ์์ ํด๋ฌผ ์ฌ์ฉ ์์ธ, ๊ฒฝ๊ธฐ๋ ๋ณด์๊น์น, ์ค์ด์๋ฐ์ด ์์ฐ์ , ์กฐ๊ธฐ์ ์ฌ์ฉ ์ถฉ์ฒญ๋ ๋๋ฐ๊น์น, ํธ๋ฐ๊น์น ์ํ๊ณ ๊ตฌ์ํ ๋ง ๊ฒฝ์๋ ๋ถ์ถ๊น์น, ๊นป์ ๊น์น ์งํ ์ ๊ฐ ๋ง, ์๊ทน์ ์ด๊ณ ๋งค์ ์ ๋ผ๋ ๊ณ ๋ค๋นผ๊ธฐ, ๋์ฃผ๋์น๋ฏธ ๋ค์ํ ์ ๊ฐ๊ณผ ํด์ฐ๋ฌผ๋ก ๊น์ ๋ง ์ ์ฃผ๋ ์ ๋ณต๊น์น ์ ์ ์๋
์ผ๋ก ์ฌ๋ฃ์ ์๋ ๋ง์ ์ด๋ฆผ ์์ ์์๊ณผ ๋น๊ต ํ๊ตญ ์์ : ์ต์ด์กฐ๋ฆฌ (steaming) ๋ฐฉ์์ ์จ์ ์๊ฐ๋ฝ ๋๋น ์ฌ์ฉ ์์ ์์ : ๊ฑด์ด์กฐ๋ฆฌ (roasting) ๋ฐฉ์์ ์ํด ํฌ๊ณผ ์ค๋ธ ์ฌ์ฉ, ํฌํฌ ๋์ดํ ์ฌ์ฉ ๊ธ๋ก๋ฒ์ ํต์์ : ๋ธ๋ผ์ง, ์ค๊ตญ ํ๊ตญ, ์ผ๋ณธ, ์ค๊ตญ์ ์ ๊ฐ๋ฝ ๋น๊ต ํ๊ตญ ์ผ๋ณธ ์ค๊ตญ ๋ช
์นญ ์ ๊ฐ๋ฝ ํ์ ์ฝฐ์ด์ฆ ์ฌ์ง ๊ธ์ ๋๋ฌด ํ๋ผ์คํฑ, ๋๋๋ฌด ํํ ๋ฉ์ํ๊ณ , ๊ตต๊ธฐ ์ฐจ์ด๊ฐ ์ ๋ค ๋์ด ๋พฐ์กฑํ๊ณ ๊ธธ์ด๊ฐ ์งง๋ค, ๊ตต๊ธฐ ์ฐจ์ด๊ฐ ํฌ๋ค ๊ธธ์ด๊ฐ ๊ธธ๋ค, ๊ตต๊ธฐ ์ฐจ์ด๊ฐ ํฌ๋ค ์ค๊ตญ์ ์์ฌ ์์ ํฐ ์ ์์ ์์์ ๋๋์ด ๋จน๋๋ค ์ข์๋ฐฐ์น : ์ฃผ๋น์ด ๋๋ ์๋์ด ์์(์์ชฝ)์ ์๊ณ ์ฃผ์ธ์ ํ์ (๋ฐ๊นฅ์ชฝ)์ ์๋๋ค ์ฃผ๋น ์ฐ์ : ์์์ด ๋์ค๋ฉด ์ฃผ๋น ์์ ๋๊ณ , ์ ์ ์ข
๋ฅ๋ ๋ฌผ์ด์ ์ ํ๋ค ์คํผ์ ํ์ ๋จน์ ๋๋ง ์ฌ์ฉ, ๋ฐฅ์ด๋ ํ์ด ๋ด๊ธด ๊ทธ๋ฆ์ ๋ค๊ณ ๋จน๋๋ค. ์ฌ์ฉํ ์๊ฐ๋ฝ์ ๋ค์ง์ด ๋๋๋ค ํ์ ์ํ : ์์์ ๊ฐ์ด ๋๋ ค์ค๋ค. ๊ฐ์ธ ์ ์๋ ์ปต์ ๋์ง ์๋๋ค. ๊ธ๋ก๋ฒ ์ ํต์์ : ํ๋์ค ํ๋์ค์์ ๊ธ๊ธฐ์ ๋๋ ํ๋ ์ฌ๋ ์์์ ์ฝ๋ฅผ ํ์ฉ ๊ฑฐ๋ฆฌ๋ ํ๋ ๋ฐ์์ ๋ค๋ฅธ ์ฌ๋๊ณผ ๋ชธ์ด ๋ฟ์์ ๋ ์ฌ๊ณผ๋ฅผ ํ์ง ์๋ ํ๋ ์๋น์์ ์ง์์ ๋ถ๋ฅด๋ ํ๋ (๋์ด ๋ง์ฃผ์น๋ฉด ๋์ง์ผ๋ก ํธ์ถ) ์ธ๋ชจ (๋ฐ๊ฟ ์ ์๋ ๊ฒ)์ ๋ํ ์๊ธฐ (์นํ ์ฌ์ด๋ผ๋) ๋ชจ๋ฅด๋ ์ฌ๋๊ณผ ๋์ด ๋ง์ฃผ์น๋ ๊ฒ ํ๋์ค ์ฝ์ค ์๋ฆฌ ์์
์ํ๋ฆฌํฐํ(์์ ์ฃผ) ์ํธ๋ / ์คํ ๋๋ธํ ์ ๋ผ (์์ ์๋ฆฌ / ์ก๋ฅ ์๋ฆฌ) ํ๋ก๋ง์ฅฌ (์น์ฆ) ๋์ ํธ ์ปคํผ / ์ฐจ ํ
์ด๋ธ ๋งค๋
์ด๋์์๊ฒ ๊ฐ์ฌ์ ํ์๋ก ๊ฝ์ด๋ ํฌ๋์ฃผ, ํ์ด ๋ฑ์ ๊ฐ๋ฒผ์ด ์ ๋ฌผ์ ํ๊ณ , ์ ๋ฌผ์ ์์ฃผ์ธ์๊ฒ ๊ฑด๋ธ๋ค ๋ฏธ๋ฆฌ ์ด์ผ๊ธฐ ๋ ๊ฒ์ด ์๋๋ฉด, ์์์ ์ ๋ฌผํ์ง ๋ง์, ๊ณผ์๋ ์ผ์์ด ์ค๋ณต๋์ง ์๋๋ก ํ๋ค ์์์ ์ ๋ ๋จ๊ธฐ์ง ์๋๋ค (๋ง ์์ด์ ๋จ๊ธด๊ฑธ๋ก ๊ฐ์ฃผ) ์์์ด ๋ฐ๋ ๋๋ง๋ค “๋ง์๋ค"๋ ์นญ์ฐฌ์ ๋นผ๋์์๋ ์๋๋ค ํ๋์ค ์์ธ ์ถ์
๋ณด๋ฅด๋ ์์ธ ํ์คํฐ๋ฒ ๋ณด์กธ๋ ๋๋ณด ์ถ์ ํ๋์ค ๋ํ ์์
๋ฐ๊ฒํธ : ๋ฐ๊ฐ๋ฃจ + ๋ฌผ + ์๊ธ + ์ด์คํธ ํฌ๋ก์์ : ๋ฐ๊ฒํธ ์ฌ๋ฃ + ์คํ + ๋ฒํฐ + ๋ถ์ ์์ค๊น๋ฅด๊ณ : ์์ฉ ๋ฌํฝ์ด ํธ์๊ทธ๋ผ : ์ง๋ฐฉ์ด ๋ง์ ๊ฑฐ์์ ๊ฐ ํฌ๋ ํ : ๋ฐ๊ฐ๋ฃจ๋ ๋ฉ๋ฐ๊ฐ๋ฃจ ๋ฐ์ฃฝ์ ์๊ฒ ๋ถ์น๊ณ ๊ทธ ์์ ๋ค์ํ ์์ฌ๋ฃ๋ฅผ ์น์ด ์ธ๋จน๋ ๋ฐฉ์ 1#include <bits/stdc++.h> 2using namespace std; 3 4char board[1000][1000] = { NULL }; 5int n; 6 7tuple<int, int, int> getlength(int sx, int sy, int dx, int dy) { 8 int cnt = 0; 9 int x = sx; 10 int y = sy; 11 12 while (true) { 13 x += dx; 14 y += dy; 15 if (y < 0 || y >= n || x < 0 || x >= n || board[x][y] != '*') { 16 return { cnt, x-dx, y-dy }; 17 } 18 cnt++; 19 } 20} 21 22int main() { 23 cin.tie(0)->sync_with_stdio(false); 24 cin >> n; 25 26 pair<int, int> heart = { 0, 0 }; 27 tuple<int, int, int> ass = { 0, 0, 0 }; 28 29 for (int i = 0; i < n; i++) { 30 for (int j = 0; j < n; j++) { 31 cin >> board[i][j]; 32 if (board[i][j] == '*' && heart.first == 0) 33 heart = { j, i + 1 }; 34 } 35 } 36 37 ass = getlength(heart.second, heart.first, 1, 0); 38 39 cout << heart.second+1 << " " << heart.first+1 << "\n"; 40 cout << get<0>(getlength(heart.second, heart.first, 0, -1)) << " " 41 << get<0>(getlength(heart.second, heart.first, 0, 1)) << " " 42 << get<0>(ass) << " " 43 << get<0>(getlength(get<1>(ass), get<2>(ass)-1, 1, 0)) << " " 44 << get<0>(getlength(get<1>(ass), get<2>(ass)+1, 1, 0)); 45 46 return 0; 47} ๋ฌธ์ ์ ์ฌ๊ฐํ ํ์ ํฌ๊ธฐ N๊ณผ ์ฟ ํค์ ์ ์ฒด ๋ชจ์์ด 2์ฐจ์ ๋ฌธ์๋ก ์ฃผ์ด์ง๋ค. 1๋ฒ์งธ ์ค์๋ ์ฌ์ฅ์ ์์น๋ฅผ ์ถ๋ ฅํ๋ค. 2๋ฒ์งธ ์ค์๋ ์ผํ, ์ค๋ฅธํ, ํ๋ฆฌ, ์ผ๋ค๋ฆฌ, ์ค๋ฅธ๋ค๋ฆฌ์ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ๋ค. ๊ธ๋ก ์ค๋ช
ํ๊ธฐ ์ฝ์ง ์๋ค. ํด๊ฒฐ๋ฐฉ๋ฒ ์
๋ ฅ ๋ฐ์ผ๋ฉด์ ์ฌ์ฅ์ ์์น๋ฅผ ๋ด๋ค. ์ฌ์ฅ์ ์์น๋ฅผ ํตํด ํ๋ฆฌ์ ๋์ ๋ด๋ค. ์ผํ, ์ค๋ฅธํ, ํ๋ฆฌ์ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ๋ค. ํ๋ฆฌ์ ๋์ ์ด์ฉํด ์ผ๋ค๋ฆฌ, ์ค๋ฅธ๋ค๋ฆฌ์ ๊ธธ์ด๋ฅผ ์ถ๋ ฅํ๋ค. getlength() ํจ์๋ฅผ ์ ์ํ์ฌ ๊ฐ ๊ธธ์ด๋ฅผ ๊ตฌํ๋ค. ๋งํ๋ ๋ถ๋ถ x, y๊ฐ ํผ๋๋์ด์ ๊ณ ์น๋๋ฐ ์๊ฐ์ ๋ง์ด ์ก์ ๋จน์ c++๋ก 2์ฐจ์ ๋ฐฐ์ด ๋ค๋ฃจ๋ ๋ฌธ์ ๋ฅผ ์ด์ฌํ ํ์ด๋ณด์! ์ฒซ๋ฒ์งธ BFS ํ์ด 1from collections import deque 2 3def solution(storey): 4 answer = 0 5 q = deque() 6 q.append((storey, 0)) 7 visited = [False] * (10**8+1) 8 9 while q: 10 cur, cnt = q.popleft() 11 12 13 visited[cur] = True 14 while cur != 0 and cur%10 == 0: 15 cur = cur // 10 16 if cur == 0: 17 answer = cnt 18 break 19 for j in [-1, 1]: 20 dest = cur + j 21 if 0 <= dest <= 10**8 and not visited[dest]: 22 q.append((dest, cnt+1)) 23 24 return answer ๊ฐ์ ํ DFS ํ์ด 1answer = 10**8 2def dfs(cur, cnt): 3 global answer 4 if cur == 0: 5 answer = min(answer, cnt) 6 return 7 while cur % 10 == 0: 8 cur /= 10 9 10 if cur%10 < 5: 11 dfs(cur//10, cnt+(cur%10)) 12 elif cur%10 > 5: 13 dfs(cur//10+1, cnt+(10-cur%10)) 14 else: 15 dfs(cur//10, cnt+(cur%10)) 16 dfs(cur//10+1, cnt+(10-cur%10)) 17 18def solution(storey): 19 dfs(storey, 0) 20 return answer ๋ฌธ์ ์ฃผ์ธ๊ณต ๋ฏผ์๋ ํ๋ฒ ์๋ ๋ฒ ์ดํฐ๋ฅผ ํ๋ฉด -1, +1, -10, +10 ๋ฑ ์ ๋๊ฐ์ด $10^c$ (c>=0์ธ ์ ์) ๋งํผ ์ด๋ ํ ์ ์๋ค 0์ธต๊น์ง ๊ฐ๋ ค๋ฉด ์ต์ ๋ช ๋ฒ ๋ง์ ์ด๋ํ ์ ์๋์ง ๊ตฌํ๋ผ 1 <= storey <= 100,000,000 TC input 16
ouput 6
ํด๊ฒฐ๋ฐฉ๋ฒ ์ฒ์์๋ bfs๋ฅผ ์ด์ฉํด์ +1, -1 ํ๋ฒ์ฉํ๋ฉฐ ๋นํจ์จ์ ์ผ๋ก ํด๊ฒฐํ์๋ค ๋๋ฒ์งธ dfsํ์ด์์๋ ์ผ์ ์๋ฆฌ์ ๋ฐ๋ผ ์๋ฆฟ์๋ฅผ ์ฌ๋ฆฌ๊ฑฐ๋ ๋ด๋ฆฌ๊ณ , ์ผ์ ์๋ฆฌ๋ฅผ ํ๋ฒ์ ๊ณ์ฐํ์ฌ ๋ ๋์ ํ์ด๋ก ํ ์ ์์๋ค 1๊ณผ๋ชฉ : ์ํํธ์จ์ด ์ค๊ณ ๊ฒฐํฉ๋ ์๋ฃ ๊ฒฐํฉ๋ : ๋ชจ๋ ๊ฐ์ ์ธํฐํ์ด์ค๊ฐ ์๋ฃ ์์๋ก๋ง ๊ตฌ์ฑ๋ ๋์ ๊ฒฐํฉ๋ ์คํฌํ ๊ฒฐํฉ๋ : ๋ชจ๋ ๊ฐ์ ์ธํฐํ์ด์ค๋ก ๋ฐฐ์ด์ด๋ ๋ ์ฝ๋ ๋ฑ์ ์๋ฃ ๊ตฌ์กฐ๊ฐ ์ ๋ฌ๋ ๋์ ๊ฒฐํฉ๋ ์ ์ด ๊ฒฐํฉ๋ : ํ ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋๊ณผ ์ ์ด ์ ํธ๋ฅผ ์ด์ฉํ์ฌ ํต์ ํ๊ณ , ๊ณต์ ๋๋ ๊ณตํต ๋ฐ์ดํฐ ์์ญ์ ์ฌ์ฉํ ๋์ ๊ฒฐํฉ๋ ์ธ๋ถ ๊ฒฐํฉ๋ : ์ด๋ค ๋ชจ๋์์ ์ ์ธํ ๋ฐ์ดํฐ(๋ณ์)๋ฅผ ์ธ๋ถ์ ๋ค๋ฅธ ๋ชจ๋์์ ์ฐธ์กฐํ ๋์ ๊ฒฐํฉ๋ ๊ณต์ ๊ฒฐํฉ๋ : ๊ณต์ ๋๋ ๊ณตํต ๋ฐ์ดํฐ ์์ญ์ ์ฌ๋ฌ ๋ชจ๋์ด ์ฌ์ฉํ ๋์ ๊ฒฐํฉ๋ ๋ด์ฉ ๊ฒฐํฉ๋ : ํ ๋ชจ๋์ด ๋ค๋ฅธ ๋ชจ๋์ ๋ด๋ถ ๊ธฐ๋ฅ ๋ฐ ๊ทธ ๋ด๋ถ ์๋ฃ๋ฅผ ์ง์ ์ฐธ์กฐํ๊ฑฐ๋ ์์ ํ ๋์ ๊ฒฐํฉ๋ ์์ง๋ ์์ฐจ์ ์์ง๋ (Sequential Cohesion) ๊ตํ์ ์์ง๋ (Communicational Cohesion) ์ ์ฐจ์ ์์ง๋ (Procedural Cohesion) ์๊ฐ์ ์์ง๋ (Temporal Cohesion) ๋
ผ๋ฆฌ์ ์์ง๋ (Logical Cohesion) ์ฐ์ฐ์ ์์ง๋ (Coincidental Cohesion) ์ ์ค์ผ์ด์ค(Use Case)์ ๊ตฌ์ฑ ์์ ๊ฐ์ ๊ด๊ณ ์ฐ๊ด ๊ด๊ณ ํฌํจ ๊ด๊ณ ํ์ฅ ๊ด๊ณ ์ผ๋ฐํ ๊ด๊ณ ์๋ฃํ๋ฆ๋์ ๊ฐ ์์๋ณ ํ๊ธฐ ํํ Process : ์ Data Flow : ํ์ดํ Data Store : ํํ์ Terminator : ์ฌ๊ฐํ ์ถ์ํ์ ์ข
๋ฅ ์๋ฃ ์ถ์ํ ๊ณผ์ ์ถ์ํ ์ ์ด ์ถ์ํ UML ๋ชจ๋ธ์์์ ๊ด๊ณ Aggregation : ์งํฉ ๊ด๊ณ Generalization : ์ผ๋ฐํ ๊ด๊ณ Composition : ํฌํจ ๊ด๊ณ Dependency : ์์กด ๊ด๊ณ Realization : ์ค์ฒดํ ๊ด๊ณ 2๊ณผ๋ชฉ : ์ํํธ์จ์ด ๊ฐ๋ฐ ๋ฒ์น ํ๋ ํ ๋ฒ์น : ์ค๋ฅ์ 80%๋ ์ ์ฒด ๋ชจ๋์ 20% ๋ด์์ ๋ฐ๊ฒฌ๋๋ค๋ ๋ฒ์น ํด์ฑํจ์ ์ข
๋ฅ ์ ์ฐ๋ฒ, ์ ๊ณฑ๋ฒ, ํด๋ฉ๋ฒ, ๊ธฐ์ ๋ณํ๋ฒ, ๋์์ ์ฝ๋ฉ๋ฒ, ๊ณ์ ๋ถ์๋ฒ(์ซ์ ๋ถ์๋ฒ), ๋ฌด์์๋ฒ
ํ
์คํธ ์ข
๋ฅ ์ํ ํ
์คํธ : ๊ฐ๋ฐ์์ ์ํด ์ํ๋๋ ํ
์คํธ ๋ฒ ํ ํ
์คํธ : ์ฌ์ฉ์๊ฐ ์ํํ๋ ํ
์คํธ 3๊ณผ๋ชฉ : ๋ฐ์ดํฐ๋ฒ ์ด์ค ๊ตฌ์ถ ์คํค๋ง ์ข
๋ฅ ๊ฐ๋
์คํค๋ง : ๊ฐ์ฒด, ์์ฑ, ๊ด๊ณ๋ฅผ ์ ์ํ๋ ์คํค๋ง ๋ด๋ถ ์คํค๋ง : ๋ฌผ๋ฆฌ์ ์ ์ฅ ๊ตฌ์กฐ๋ฅผ ์ ์ํ๋ ์คํค๋ง ์ธ๋ถ ์คํค๋ง : ์ฌ์ฉ์ ๋ทฐ๋ฅผ ์ ์ํ๋ ์คํค๋ง ์ด์ํ์ ์ฝ์
์ด์, ์ญ์ ์ด์, ๊ฐฑ์ ์ด์ ๋กํน ๋กํน ๋จ์ โฌ๏ธ -> ๋ณํ์ฑ ์์ค โฌ๏ธ 4๊ณผ๋ชฉ : ํ๋ก๊ทธ๋๋ฐ์ธ์ดํ์ฉ ๊ต์ฐฉ ์ํ์ ์กฐ๊ฑด Mutual Exclusion Hold and Wait No Preemption Circular Wait 5๊ณผ๋ชฉ : ์ ๋ณด์์คํ
๊ตฌ์ถ ๊ด๋ฆฌ ๋ธ๋ผ์ฐํฐ : ๋ธ๋ฆฌ์ง์ ๋ผ์ฐํฐ์ ๊ธฐ๋ฅ์ ๋ชจ๋ ๊ฐ์ถ๊ณ ์๋ ๋คํธ์ํฌ ์ฅ๋น Cocomo ๋ชจํ ์กฐ์งํ (Organic Mode) : 5๋ง ๋ผ์ธ ์ดํ์ ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐํ๋ ์ ํ ๋ฐ๋ถ๋ฆฌํ (Semi-detached Mode) : 30๋ง ๋ผ์ธ ์ดํ์ ์ํํธ์จ์ด๋ฅผ ๊ฐ๋ฐํ๋ ์ ํ ๋ด์ฅํ (Embedded Mode) : ์ด๋ํ ๊ท๋ชจ์ ์ํํธ์จ์ด, 30๋ง๋ผ์ธ ์ด์ ๋ฐฐ๊ฒฝ ํ
์ปค ๋ถํธ์บ ํ ์ต์ข
๋ฐํ ์ ๋ ์ด๋ค. gpt ํ๋กฌํํธ ๋ถ๋ถ ์์ ์ main ๋ธ๋์น์ ๋ฐ์ํ๊ณ , EC2 ์๋ฒ์ ๋ฐฐํฌํ๋ค. ๋ฌธ์ ๋ฐฐํฌํ ์๋ฒ์์ websocket ์ฐ๊ฒฐ์ด 404 ์๋ฌ๋ฅผ ๋ฐํํ๋ค. (๋ด์ผ์ด ์ต์ข
๋ฐํ์ธ๋ฐ,,,) ๋ค๋ฅธ http ์์ฒญ์ ์ ์์ ์ผ๋ก ์ฒ๋ฆฌ๋์ง๋ง ์น์์ผ๋ง ์ฒ๋ฆฌ๋์ง ์๋ ๊ฒ์ ํ์ธํ๋ค. nginx์ log 1{IP์ฃผ์} - - [02/Aug/2024:10:59:04 +0000] "GET /ws/chatrooms/294?user_id=296 HTTP/1.1" 404 22 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15" 2{IP์ฃผ์} - - [02/Aug/2024:10:59:05 +0000] "GET /ws/chatrooms/294?user_id=296 HTTP/1.1" 404 22 "-" "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.5 Safari/605.1.15" ์ฌ๊ณ ํ๋ฆ nginx ์ค์ ๋ฌธ์ ์ธ๊ฐ? X nginx ์ค์ ์ ๋ณ๊ฒฝ๋์ง ์์๋ค. ๋ฐฐํฌํ๊ฒฝ์ ๋ฌธ์ ์ธ๊ฐ? X ๋ก์ปฌ์์ ์คํํ ์๋ฒ์์๋ ๋์ผํ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์๋ค. ์ด๋ฒ ๋ฐฐํฌ์์ ๋ณ๊ฒฝ๋ ์์ค์ฝ๋๊ฐ ๋ฌธ์ ์ธ๊ฐ? X ์ก์์ผ๋ก ํ์ธํ์ ๋๋, ๋ณ๊ฒฝ๋ ๋ถ๋ถ์ด ์น์์ผ๊ณผ ๊ด๋ จ์ด ์๋ค. ๋ก์ปฌ์์ ์ด์ ๋ฒ์ ์ผ๋ก reset ํ ์๋ ํด๋ณด์์ง๋ง ๋ฌธ์ ๊ฐ ํด๊ฒฐ๋์ง ์์๋ค. Docker image ๋ฌธ์ ์ธ๊ฐ? X ๋ฐฑ์๋ ์๋ฒ๋ python:slim ์ด๋ฏธ์ง๋ฅผ ์ฌ์ฉํ๊ณ ์์ผ๋ฉฐ, ํด๋น ์ด๋ฏธ์ง๊ฐ ๋ณ๊ฒฝ๋์ด์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์๋ค๊ณ ์๊ฐํ๋ค. ๋ก์ปฌ์์ docker image๋ฅผ ์ฌ์ฉํ์ง ์๊ณ ์คํํด๋ณด์์ง๋ง ๋ฌธ์ ๊ฐ ํด๊ฒฐ๋์ง ์์๋ค. ์ด๋, ๋ก๊ทธ์์ warning ๋ฉ์์ง๋ฅผ ํ์ธํ๋ค. WARNING: No supported WebSocket library detected. Please use "pip install 'uvicorn[standard]'", or install 'websockets' or 'wsproto' manually. ์์ธ ๋ชจ์ข
์ ์ด์ ๋ก, ์ด์ ์ ๊ฐ๋ฐ/๋ฐฐํฌํ ๋์๋ ์กด์ฌํ๋ ์น์์ผ ๊ด๋ จ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์ฌ๋ผ์ง ๊ฒ์ด๋ค. ์ค๋ฅ๋ฅผ ํด๊ฒฐํ๊ณ ์กฐ์ฌํด๋ณธ ๊ฒฐ๊ณผ fastapi ๋ ํฌ์งํ ๋ฆฌ์ 6์๊ฐ ์ merge๋ PR์ ํ์ธํ ์ ์์๋ค. (https://github.com/fastapi/fastapi/pull/11935) ํด๋น PR์์๋ pip install fastapi[standard] ๋ฅผ ํตํด ํ์ค ์ข
์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํ๋ ๊ธฐ๋ฅ์ด ์ถ๊ฐ๋์๋ค. ์ด๋ก ์ธํด, uvicorn[standard] ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ค์นํ์ง ์์์ ๋, ์น์์ผ ๊ด๋ จ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์ค์น๋์ง ์์ ๋ฐ์ํ ๋ฌธ์ ์๋ค. ํด๊ฒฐ requirements.txt์ websockets๋ฅผ ์ถ๊ฐํด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์์๋ค. ๋ฐฐ์ด ์ ์ค์ํ ํ๋ก์ ํธ๋ฅผ ํ ๋ requirements.txt์ ํญ์ ๊ฐ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฒ์ ์ ๋ช
์ํด์ผ๊ฒ ๋ค๋ ์๊ฐ์ด ๋ค์๋ค. ์ด๋ฒ์๋ ๋ฒ์ ์ ๋ช
์ํ๋ค๋ฉด, ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ์
๋ฐ์ดํธ ๋๋๋ผ๋ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ง ์์์ ๊ฒ์ด๋ค. ๋ํ, ๋ก๊ทธ๋ฅผ ์ ํ์ธํ๊ณ , warning ๋ฉ์์ง๋ฅผ ๋์น์ง ์๋๋ก ์ฃผ์ํด์ผ๊ฒ ๋ค. ์ํฉ ํ
์ปค ๋ถํธ์บ ํ์์ ํํ๋ก์ ํธ๋ฅผ ์งํ ์ค์ด๋ค. ๋จ์ํ
์คํธ ์ฝ๋๋ ์์ฑ์ด ์๋ฃ๋์๊ณ , ํตํฉํ
์คํธ ์ฝ๋๋ฅผ ์์ฑ ์ค์ด๋ค. sqlite in-memory db๋ฅผ ์ฌ์ฉํด์ ํ
์คํธ ์ค์ธ๋ฐ, ํ
์ด๋ธ์ด ์๋ค๋ ์๋ฌ๊ฐ ๋ฐ์ํ๋ค. ํ
์คํธ ์ ์ ํ
์ด๋ธ์ ์์ฑํ๋ ์ฝ๋๊ฐ ์คํ๋จ์๋ ๋ถ๊ตฌํ๊ณ , ์๋ฌ๊ฐ ๋ฐ์ํ๋ค. ์ธ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋ ํ์ผ๋ก ์ ์ฅํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ฉด ์๋ฌ๊ฐ ๋ฐ์ํ์ง ์๋ ๊ฒ์ ๋ณด๊ณ ๋ฌธ์ ์ ์์ธ์ ํ์
ํ ์ ์์๋ค. ์ฝ๋ 1from database import Base, engine 2from fastapi.testclient import TestClient 3 4from main import app 5from models import * 6 7# ํ
์ด๋ธ์ ์์ฑํ๋ ์ฝ๋์ด๋ค 8Base.metadata.create_all(bind=engine) 9 10client = TestClient(app) 11 12 13class TestUserApi: 14 15 def test_create_user(self): 16 test_nickname = "test_nickname" 17 # ์๋ ์์ฒญ์ ์ฒ๋ฆฌํ๋ ์ฝ๋์์ ์ค๋ฅ๊ฐ ๋ฐ์ํ๋ค 18 response = client.post( 19 "/api/users", 20 json={"nickname": test_nickname}, 21 ) 22 assert response.status_code == 200 23 assert response.json()["nickname"] == test_nickname ์์ธ ํ
์ด๋ธ์ ์์ฑํ ๋ ๋ง๋ค์ด์ง๋ ์ธ์
๊ณผ TestClient๊ฐ ์์ฒญ์ ์ฒ๋ฆฌํ ๋ ์ฌ์ฉํ๋ ์ธ์
์ด ๋ค๋ฅด๋ค. ํด๊ฒฐ ๋ฐฉ๋ฒ TestClient๋ด์ get_db() ํจ์๋ฅผ ์์๋ก ์ฃผ์
ํ๋ค ๋ฐ์ดํฐ๋ฒ ์ด์ค๋ฅผ ์ฐ๊ฒฐํ ๋, ๋จ์ผ ์ธ์
์ ์ฌ์ฉํ๋๋ก ํ๋ค. 1from database import Base, engine, get_db 2from sqlalchemy.orm import sessionmaker 3from fastapi.testclient import TestClient 4 5from main import app 6from models import * 7 8Base.metadata.create_all(bind=engine) 9 10client = TestClient(app) 11 12# ํ
์คํธ์์ ์ฌ์ฉํ ์ธ์
์ ์์ฑํ๋ค 13TestingSessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) 14 15 16Base.metadata.create_all(bind=engine) 17 18# get_db() ํจ์๋ฅผ ์ฌ์ ์ํ๋ค 19def override_get_db(): 20 try: 21 db = TestingSessionLocal() 22 yield db 23 finally: 24 db.close() 25 26# get_db() ํจ์๋ฅผ ์ฌ์ ์ํ ํจ์๋ฅผ ์ฃผ์
ํ๋ค 27app.dependency_overrides[get_db] = override_get_db 28 29 30class TestUserApi: 31 32 def test_create_user(self): 33 test_nickname = "test_nickname" 34 response = client.post( 35 "/api/users", 36 json={"nickname": test_nickname}, 37 ) 38 assert response.status_code == 201 39 assert response.json()["nickname"] == test_nickname 1engine = create_engine( 2 os.getenv("DATABASE_URL"), 3 # sqlite๋ฅผ ์ฌ์ฉํ ๋, ์ฌ๋ฌ ์ค๋ ๋์์ ์ฐ๊ฒฐ์ด ๊ฐ๋ฅํ๋๋ก ์ค์ ํ๋ค 4 connect_args={"check_same_thread": False}, 5 # ๋จ์ผ ์ธ์
์ ์ฌ์ฉํ๋๋ก ์ค์ ํ๋ค 6 poolclass=StaticPool, 7) 09-process1 ์์ธ์ ์ธ ์ ์ด ํ๋ฆ ํ์ ๋งค์ปค๋์ฆ ์์ธ (Exception) ์์ ๋งค์ปค๋์ฆ ํ๋ก์ธ์ค ์ปจํ
์คํธ ์ ํ OS ์ํํธ์จ์ด์ ํ๋์จ์ด ํ์ด๋จธ๋ก ๊ตฌํ ์๊ทธ๋ OS ์ํํธ์จ์ด๋ก ๊ตฌํ nolocal ์ ํ ์์ธ ํ
์ด๋ธ (Exception Tables) ๊ฐ ์ด๋ฒคํธ ํ์
์ ์์ธ๋ฒํธ k๋ฅผ ๊ฐ๋๋ค ๋น๋๊ธฐํ ์์ธ (Interrupt) ์
์ถ๋ ฅ ์ธํฐ๋ฝํธ (ctrl + c)
ํ๋ ๋ฆฌ์
์ธํฐ๋ฌํธ
์ํํธ ๋ฆฌ์
์ธํฐ๋ฝํธ
๋๊ธฐํ ์์ธ Traps : ๋ช
๋ น์ด์ ๊ฒฐ๊ณผ๋ก ๋ฐ์ํ๋ ์๋์ ์ธ ์์ธ (syscall)
Faults : ํธ๋ค๋ฌ๊ฐ ์ ์ ํ ์ ์๋ ์๋ฌ์ ๊ฒฐ๊ณผ๋ก ๋ฐ์ (page faults)
Aborts : ๋ณต๊ตฌ ๋ถ๊ฐ๋ฅํ ์๋ฌ์ ๊ฒฐ๊ณผ๋ก ๋ฐ์
Page Fault ์ฌ์ฉ์ ๋ฉ๋ชจ๋ฆฌ์ ํน์ ํ์ด์ง๊ฐ ํ์ฌ ํ๋๋์คํฌ์ ์์นํ๋ ๊ฒฝ์ฐ
์ค๋ฅ ์ฒ๋ฆฌํ์ ์ค๋ฅ๋ฅผ ๋ฐ์์ํจ ๋ช
๋ น์ด๋ฅผ ๋ค์ ์คํํ๋ค
1int a [1000]; 2int main () { 3a[500] = 13; 4} Process ํ๋ก์ธ์ค : ์ด์์ฒด์ ๊ฐ ๋ง๋ค์ด ์ฃผ๋ ํ๋ก๊ทธ๋จ์ ํ ์คํ ์
ํ๋ก๊ทธ๋จ์ 2๊ฐ์ ์ค์ํ ์ถ์ํ ์ ๊ณต
๋
ผ๋ฆฌ์ ์ธ ์ ์ด ํ๋ฆ : ๊ฐ ํ๋ก๊ทธ๋จ์ด CPU๋ฅผ ๋
์ ํ๋ ๊ฒ์ฒ๋ผ ๋ณด์ด๊ฒ ํ๋ค ์ฌ์ ์ธ ์ฃผ์ ๊ณต๊ฐ : ๊ฐ ํ๋ก๊ทธ๋จ์ด ์ฃผ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋
์ ํ๋ ๊ฒ ์ฒ๋ผ ๋ณด์ด๋๋ก ํ๋ค ์ด๋ป๊ฒ? ํ๋ก์ธ์ค์ ์คํ์ด ์๋ก ๊ต๋๋ก ์คํ๋๋ค ์ฃผ์๊ณต๊ฐ์ ๊ฐ์๋ฉ๋ชจ๋ฆฌ ์์คํ
์ ์ํด ๊ด๋ฆฌ Multiprocessing (๊ณผ๊ฑฐ) ํ์ฌ ๋ ์ง์คํฐ๋ค์ ๋ฉ๋ชจ๋ฆฌ์ ๋ณด๊ด
๋ค์ ํ๋ก์ธ์ค๋ฅผ ์คํํ๊ธฐ ์ํด ์ค์ผ์ฅด๋ง
๋ณด๊ด๋ ๋ ์ง์คํฐ๋ค์ ๊ฐ์ ธ์ค๊ณ ์ฃผ์๊ณต๊ฐ์ ์ ํ (context switch)
Multiprocessing (ํ๋) ๋ฉํฐ์ฝ์ด ํ๋ก์ธ์
๊ฐ ์ฝ์ด๋ ๋ณ๋์ ํ๋ก์ธ์ค๋ฅผ ์คํ ๊ฐ๋ฅ
๋์์ฑ ํ๋ก์ธ์ค ๋ ํ๋ก์ธ์ค์ ์คํ์๊ฐ์ด ์๋ก ์ค์ฒฉ๋๋ฉด -> concurrent ์ค์ฒฉ๋์ง ์๊ณ ์์ฐจ์ ์ผ๋ก ์คํ๋๋ค๋ฉด -> sequential fork 1int fork(void) ํธ์ถํ๋ ํ๋ก์ธ์ค์ ๋์ผํ ์ ํ๋ก์ธ์ค ์์ฑ ์์ ํ๋ก์ธ์ค๋ 0์ ๋ฆฌํด ๋ถ๋ชจ ํ๋ก์ธ์ค๋ ์์ ํ๋ก์ธ์ค์ pid ๋ฆฌํด exit 1void exit(int status) ์ข
๋ฃ ์ํ status ๊ฐ์ ๊ฐ์ง๊ณ ์ข
๋ฃ (์ ์์ด๋ฉด 0) atexit() ํจ์๋ exit ํ ๋ ์คํํ ํจ์๋ฅผ ๋ฑ๋ก ์ข๋น (Zombies) ์ข
๋ฃ๋์์ง๋ง, ์์ง ์ ๋ฆฌ๋์ง ์์ ํ๋ก์ธ์ค
1void fork8() { 2if (fork() == 0) { 3 printf("Running child, PID = %d\n", getpid()); 4 while (1) 5 ; 6} 7else { 8 printf("Terminating Parent, PID = %d\n", getpid()); 9 exit(0); 10} 11} 10-process2 wait 1int wait (int *child_status) ํ์ฌ ํ๋ก์ธ์ค๋ฅผ ์์ ์ ์์ ํ๋ก์ธ์ค๋ค ์ค์ ํ๋๊ฐ ์ข
๋ฃ๋ ๋๊น์ง ์ ์ง์ํจ๋ค
๋ฆฌํด๊ฐ์ ์ข
๋ฃํ ์์ ํ๋ก์ธ์ค์ PID
child_status != NULL์ธ ๊ฒฝ์ฐ, ์์ ํ๋ก๊ทธ๋จ์ ์ข
๋ฃ ์ด์ ๋ฅผ ๋ํ๋ด๋ ์ํ์ ๋ณด๋ฅผ ๊ฐ๋๋ค
example
1pid_t wpid = wait(&child_status); 2if (WIFEXITED(child_status)) 3 printf("Child %d terminated with exit status %d\n", wpid, WEXITSTATUS(child_status)); 4else 5 printf("Child %d terminate abnormally\n", wpid); waitpid 1waitpid(pid, &status, options) pid : ํน์ pid์ ํ๋ก์ธ์ค๋ฅผ ๊ธฐ๋ค๋ฆฐ๋ค. -1์ด๋ฉด wait()๊ณผ ๋์ผ
options : 0 (์ข
๋ฃ๋ ์์์ ๊ธฐ๋ค๋ฆฐ๋ค), WNOHANG(==1 ํ๋ฒ๋ง ์ฒดํฌ), WUNTRACED(==2, ์ ์ง๋๊ฑฐ๋ ์ข
๋ฃ๋ ์์์ ๊ธฐ๋ค๋ฆฐ๋ค)
sleep 1// ์๊ธฐ ์์ ์ secs์ด ๋์ ์ ์ง 2unsigned int sleep(unsigned int secs) 3// ํธ์ถํ๋ ํ๋ก์ธ์ค๋ฅผ ์๊ทธ๋ ๋ฐ์ ๋ ๊น์ง ์ ์ฌ์ด๋ค 4int pause(void) execve 1int execve(char *filename, char *argv[], char *envp[]) ์คํ ํ์ผ filename์ ํ์ฌ ํ๋ก์ธ์ค์ ํ๊ฒฝ๋ณ์๋ฅผ ์ด์ฉํ๋ฉด์ argv๋ก ํ์ฌ์ code, data, stack์ ๋ฎ์ด ์์
example
1if ((pid = fork()) == 0) { 2 if (execve(myargv[0], myargv, environ) < 0) { 3 printf("%s: Command not found.\n", myargv[0]); 4 exit(1); 5 } 6} shell ์ฌ์ฉ์์ ๋ช
๋ น์ ์ฒ๋ฆฌํด์ฃผ๋ ์์ฉ ํ๋ก๊ทธ๋จ
Utility : file๋ก ๊ตฌํ๋ ๋ช
๋ น์ด Built-in : ์ฝ๋๋ก ๊ตฌํ๋ ๋ช
๋ น์ด eval 1void eval(char *cmdline) { 2 char *argv[MAXARGS]; 3 int bg; 4 pid_t pid; 5 6 bg = parseline(cmdline, argv); 7 if (!builtin_command(argv)) { 8 if ((pid = fork()) == 0) { 9 if (execve(argv[0], argv, environ) < 0) { 10 printf("%s: Command not found.\n", argv[0]); 11 exit(0); 12 } 13 } 14 15 if (!bg) { 16 int status; 17 if (waitpid(pid, &status, 0) < 0 ) 18 unix_error("waitfg: waitpid error"); 19 } 20 else 21 printf("%d %s", pid, cmdline); 22 } 23} -> ๋ฐฑ๊ทธ๋ผ์ด๋ ์์
์ด ์ข
๋ฃ๋๋ฉด zombie๊ฐ ๋๋ค
ํด๊ฒฐ๋ฐฉ๋ฒ : signal 11-signal Signal ์ด๋ค ์ด๋ฒคํธ๊ฐ ์์คํ
์ ๋ฐ์ํ๋ค๋ ๊ฒ์ ํ๋ก์ธ์ค์๊ฒ ์๋ ค์ฃผ๋ ์งง์ ๋ฉ์์ง
Receiving a signal ๋ชฉ์ ์ง ํ๋ก์ธ์ค๊ฐ ์๊ทธ๋์ ๋ฐ์ ๋, ์ด๋ค ํํ๋ก๋ ๋ฐ์์ ํ๋๋ก ์ปค๋์ ์ํด ์๊ตฌ๋ ๋, ์๊ทธ๋์ ๋ฐ๋๋ค๊ณ ํ๋ค.
3๊ฐ์ง ๋ฐ์ ๋ฌด์ ๋์ ํ๋ก์ธ์ค๋ฅผ ์ข
๋ฃ signal handler๋ผ๊ณ ๋ถ๋ฅด๋ ์ ์ ๋ ๋ฒจ ํจ์๋ฅผ ์คํํ์ฌ ์๊ทธ๋์ ์ก๋๋ค ์๊ทธ๋์ ํน์ง ํ๋ก์ธ์ค๋ ํน์ ์๊ทธ๋์ ์์ ์ ๋ธ๋กํ ์ ์๋ค. ๋๊ธฐํ๋ ์๊ทธ๋์ ์ต๋ ํ๋ฒ๋ง ์์ ํ ์ ์๋ค. ์ปค๋์ด context์ ๊ฐ์ง๊ณ ์๋ ๋นํธ๋ฒกํฐ pending : ๋๊ธฐ ์๊ทธ๋๋ค์ ํ์ ๋์ฐฉํ ๋๋ง๋ค pending๊ฐ์ k๋ฒ์งธ ๋นํธ๋ฅผ 1๋ก ์ค์ ์์ ํ ๋๋ง๋ค pending๊ฐ์ k๋ฒ์งธ ๋นํธ๋ฅผ 0์ผ๋ก ์ค์ blocked : ๋ธ๋ก๋ ์๊ทธ๋๋ค์ ํ์ sigprocmask ํจ์๋ฅผ ์ฌ์ฉํ์ฌ ์์ฉํ๋ก๊ทธ๋จ์ด 1๋๋ 0๋ก ์ค์ ํ๋ก์ธ์ค ๊ทธ๋ฃน ๊ฐ ํ๋ก์ธ์ค๋ ํ๋์ ํ๋ก์ธ์ค ๊ทธ๋ฃน์ ์ํ๋ค ๊ธฐ๋ณธ์ ์ผ๋ก ์์์ ๋ถ๋ชจ์ ๊ฐ์ ๊ทธ๋ฃน์ ์ํ๋ค ์์ ๊ฐ job๋ง๋ค ๋ณ๋์ ํ๋ก์ธ์ค ๊ทธ๋ฃน์ ๋ง๋ ๋ค getpgrp() : ํ๋ก์ธ์ค์ ํ๋ก์ธ์ค ๊ทธ๋ฃน์ ๋ฆฌํด setpgid() : ํ๋ก์ธ์ค์ ๊ทธ๋ฃน์ ๋ณ๊ฒฝ kill kill -9 24818 : SIGKILL์ pid 24818๋ก ๋ณด๋ kill -9 -24817 : pgid 24871์ ๊ฐ ํ๋ก์ธ์ค์ SIGKILL์ ๋ณด๋ ํค๋ณด๋๋ก๋ถํฐ ์๊ทธ๋ ๋ณด๋ด๊ธฐ ํค๋ณด๋๋ก ctrl+c (ctrl+z)๋ฅผ ๋๋ฅด๋ฉด SIGINT(SIGTSTP) ์๊ทธ๋์ด ํฌ๊ทธ๋ผ์ด๋ ํ๋ก์ธ์ค ๊ทธ๋ฃน์ ๋ชจ๋ ์์
์ผ๋ก ์ ์ก๋๋ค SIGINT : ๊ฐ ํ๋ก์ธ์ค๋ฅผ ๋ชจ๋ ์ข
๋ฃ์ํจ๋ค. SIGTSTP : ๊ธฐ๋ณธ ๋์์ ๊ฐ ํ๋ก์ธ์ค๋ฅผ ์ ์ง์ํจ๋ค. ์๊ทธ๋ ๋ฐ๊ธฐ ์ปค๋์ pnb = pending & ~blocked ๋ฅผ ๊ณ์ฐ ๊ฐ ์๊ทธ๋ ํ์
์ ์ฌ์ ์ ์ ์๋ ๊ธฐ๋ณธ ๋์์ ๊ฐ์ง๋ค. ๊ธฐ๋ณธ ๋์์ signalํจ์๋ฅผ ์ด์ฉํ์ฌ ๋ณ๊ฒฝ์ด ๊ฐ๋ฅํ๋ค (SIGSTOP๊ณผ SIGKILL์ ์์ธ) ์๊ทธ๋ ํธ๋ค๋ฌ์ ์ค์น 1handler_t *signal(int signum, handler_t *handler) handler์ ๊ฐ SIG_IGN : signum ํ์
์๊ทธ๋ ๋ฌด์ SIG_DFL : signum์ ๊ธฐ๋ณธ๋์์ผ๋ก ๋ณต๊ท ์ด์ธ์ ๊ฒฝ์ฐ : signal handler์ ์ฃผ์ ์๊ทธ๋ ๋ธ๋กํ๊ธฐ์ ํด์ ํ๊ธฐ sigprocmask ์ด์ฉ
1int sigprocmask(int how, const sigset_t *set, sigset_t *oldest); how๊ฐ์ ๋ฐ๋ผ ๋์์ด ๊ฒฐ์ ๋๋ค
SIG_BLOCK : blocked = (blocked | set) SIG_UNBLOCK : blocked = blocked & ~set SIG_SETMASK : blocked = set set ๊ด๋ จ ์ง์ ํจ์
sigemptyset : ๋ชจ๋ ์๊ทธ๋์ด ๋น์ด์๋ ์งํฉ ์์ฑ sigfillset : ๋ชจ๋ ์๊ทธ๋ ๋ฒํธ๋ฅผ 1๋ก ์ค์ sigaddset : ํน์ ์๊ทธ๋ ๋ฒํธ๋ฅผ 1๋ก ์ค์ sigdelset : ํน์ ์๊ทธ๋ ๋ฒํธ๋ฅผ 0์ผ๋ก ์ค์ ๊ฒฝ์ฃผ Race ํ์์ผ๋ก ์ธํ ๋๊ธฐํ์ ๋ฌธ์ 1void handler(int sig) { 2 int olderrno = errno; 3 sigset_t mask_all, prev_all; 4 pid_t pid; 5 6 sigfillset(&mask_all); 7 while ((pid = waitpid(-1, NULL, 0)) > 0 ) { 8 sigprocmask(SIG_BLOCK, &mask_all, &prev_all); 9 deletejob(pid); 10 sigprocmask(SIG_SETMASK, &prev_all, NULL); 11 } 12 if (errno != ECHILD) 13 sio_error("waitpid error"); 14 errno = olderno; 15} 16 17int main(int argc, char **argv) { 18 int pid; 19 sigset_t mask_all, prev_all; 20 int n = N; // N = 5 21 sigfillset(&mask_all); 22 signal(SIGCHLD, handler); 23 initjobs(); 24 25 while (n--) { 26 if ((pid = fork()) == 0) { 27 execve("/bin/date", argv, NULL); 28 } 29 // !! ์ฌ๊ธฐ์ SIGCHLD๊ฐ ๋ฐ์ํ๋ฉด ์ค๋ฅ 30 31 // ํธ๋ค๋ฌ์์ job์ accessํ์ง ๋ชปํ๋๋ก ๋ชจ๋ signal block 32 sigprocmask(SIG_BLOCK, &mask_all, &prev_all)๋ฅ 33 addjob(pid); 34 sigprocmask(SIG_SETMASK, &prev_all, NULL); 35 } 36 exit(0); 37} ๋ถ๋ชจ๊ฐ ๋จผ์ SIGCHLD ์๊ทธ๋์ด ํฐ์ง๊ธฐ ์ ์ SIG_BLOCKํ๊ณ addjob์ ํ๋ ๊ฒฝ์ฐ -> OK ๋ถ๋ชจ๊ฐ SIG_BLOCKํ๊ธฐ ์ ์ ์์์ด ๋๋๋ ๊ฒฝ์ฐ handler๊ฐ ๋จผ์ ์คํ๋๋ค addjobํ๊ธฐ์ ์ deletejob ์ํ ๋ฌดํ ๋ฃจํ ๋ฐ์ ๊ฒฝ์ฃผํ์์ ํํผํ๋ ๋๊ธฐํ ๋ฐฉ๋ฒ 1int main(int argc, char **argv) { 2 int pid; 3 sigset_t mask_all, mask_one, prev_one; 4 int n = N; // N = 5 5 sigfillset(&mask_all); 6 sigemptyset(&mask_one); 7 sigaddset(&mask_one, SIGCHLD); 8 signal(SIGCHLD, handler); 9 initjobs(); 10 11 while (n--) { 12 sigprocmask(SIG_BLOCK, &mask_one, &prev_one); // block SIGCHILD 13 if ((pid = fork()) == 0) { 14 // ์์์ SIGCHLD๋ฅผ blockํ ํ์๊ฐ ์์ผ๋ฏ๋ก ๋ค์ unblock 15 sigprocmask(SIG_SETMASK, &prev_one, NULL); // unblock SIGCHLD 16 execve("/bin/date", argv, NULL); 17 } 18 sigprocmask(SIG_BLOCK, &mask_all, NULL); 19 addjob(pid); 20 sigprocmask(SIG_SETMASK, &prev_one, NULL); 21 } 22 exit(0); 23} ๋ถ๋ชจ์
์ฅ์์ fork๊ฐ ์คํ๋๊ณ ๋์ SIGCHLD๊ฐ unblock ๋๋ ์๊ฐ์ด ๋จ ํ๋ฒ๋ ์กด์ฌ ํ์ง ์์. ํญ์ addjob์ด ๋จผ์ ์คํ๋จ -> ์ค๋ฅ X ๋ช
์์ ์ผ๋ก ํธ๋ค๋ฌ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ๋ฐฉ์ 1volatile sig_atomic_t pid; // pid๋ ์ ์ญ๋ณ์๋ก ์ ์ธ 2void sigchld_handler(int s) { 3 int orderrno = errno; 4 // sigchld_handler์์ waitpid ํ๋ ๋ฐฉ์ 5 pid = waitpid(-1, NULL, 0); 6 errno = olderrno; 7} 8void sigint_handler(int s) {} 9 10int main(int argc, char **argv) { 11 sigset_t mask, prev; 12 int n = N; // N = 10 13 signal(SIGCHLD, sigchld_handler); 14 signal(SIGINT, sigint_handler); 15 sigemptyset(&mask); 16 sigaddset(&mask, SIGCHLD); 17 18 while (n--) { 19 sigprocmask(SIG_BLOCK, &mask, &prev); // block SIGCHILD 20 if (fork() == 0) 21 exit(0); 22 23 pid = 0; 24 sigprocmask(SIG_SETMASK, &prev, NULL); 25 26 // Wait for SIGCHLD to be recieved 27 while (!pid) 28 ; 29 30 // Do some work after receiving SIGCHLD 31 printf("."); 32 33 printf("\n"); 34 exit(0); 35} sigsuspend๋ฅผ ์ฌ์ฉํ ์๊ทธ๋ ๋๊ธฐํ
1int sigsuspend(const sigset_t *mask); 2// ์๋์ ์ฝ๋๋ฅผ ๊ตฌํํ ๊ฒ๊ณผ ๋์ผ 3sigprocmask(SIG_SETMASK, &mask, &prev); 4pause(); 5sigprocmask(SIG_SETMASK, &prev, NULL); sigsuspend๋ฅผ ์ด์ฉํ ์๊ทธ๋ ๊ธฐ๋ค๋ฆฌ๊ธฐ
1int main(int argc, char **argv) { 2sigset_t mask, prev; 3int n = N; // N = 10 4signal(SIGCHLD, sigchld_handler); 5signal(SIGINT, sigint_handler); 6sigemptyset(&mask); 7sigaddset(&mask, SIGCHLD); 8 9while (n--) { 10 sigprocmask(SIG_BLOCK, &mask, &prev); // block SIGCHILD 11 if (fork() == 0) 12 exit(0); 13 14 pid = 0; 15 // Wait for SIGCHLD to be recieved 16 while (!pid) 17 sigsuspend(&prev); 18 19 // Optionally unblock SIGCHILD 20 sigprocmask(SIG_SETMASK, &prev, NULL); 21 22 // Do some work after receiving SIGCHLD 23 printf("."); 24} 25printf("\n"); 26exit(0); 27} ResponseEntity Spring์์ HttpEntity๋ผ๋ ํด๋์ค๋ฅผ ์ง์ํ๋ค HttpEntity๋ฅผ ์์๋ฐ๋ ๋ ํด๋์ค๊ฐ RequestEntity์ ResponseEntity์ด๋ค RequestEntity๋ http์์ฒญ์ ๋ณด๋ผ๋ ์ฌ์ฉํ๊ณ ResponseEntity๋ http์๋ต์ ํ ๋ ์ฌ์ฉํ๋ค ์ ์ body, header, status๋ฅผ ์ธ์๋ก ๋๊ธธ ์ ์๋ค 1public class ResponseEntity<T> extends HttpEntity<T> { 2 public ResponseEntity(HttpStatusCode status) {...} 3 4 public ResponseEntity(@Nullable T body, HttpStatusCode status) {...} 5 6 public ResponseEntity(MultiValueMap<String, String> headers, HttpStatusCode status) {...} 7 8 public ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, HttpStatusCode status) {...} 9 10 public ResponseEntity(@Nullable T body, @Nullable MultiValueMap<String, String> headers, int rawStatus) {...} 11} ์์ - ResponseEntity ์์ฑ์๋ฅผ ์ด์ฉํ๊ฑฐ๋ builder ํจํด์ ํ์ฉํด์ ์์ฑํ ์ ์๋ค 1return new ResponseEntity<>(object, HttpStatus.valueOf(200)); 2/* ๋๋ */ 3return ResponseEntity.status(HttpStatus.valueOf(200)).body(object); Messages label.properties member.register=ํ์๊ฐ์
1<%@ taglib prefix="spring" uri="http://www.springframework.org/tags" %> 2<head> 3 <title><spring:message code="member.register" /></title> 4</head> ์ฌ์ดํธ๊ฐ ์ฌ๋ฌ ์ธ์ด๋ฅผ ์ง์ํด์ผํ ๋ label_ko.properties, label_en.properties์ ๊ฐ์ด ๋ง๋ ๋ค๊ณ ํ๋ค httpํค๋์ Accept-Launguage๋ฅผ ์๋์ผ๋ก ์ธ์ํ๋ค๊ณ ํ๋๊น ํธํ ๊ฒ ๊ฐ๋ค Validate command object Validation RegisterRequestValidator 1@Override 2public void validate(Object target, Errors errors) { 3 RegisterRequest regReq = (RegisterRequest) target; 4 5 if(regReq.getEmail() == null | regReq.getEmail().trim().isEmpty()) { 6 errors.rejectValue("email", "bad"); 7 } 8 else { 9 Matcher matcher = pattern.matcher(regReq.getEmail()); 10 if(!matcher.matches()) { 11 errors.rejectValue("email", "bad"); 12 } 13 } 14 15 ValidationUtils.rejectIfEmptyOrWhitespace(errors, "name", "required"); 16 ValidationUtils.rejectIfEmpty(errors, "password", "required"); 17 ValidationUtils.rejectIfEmpty(errors, "confirmPassword", "required"); 18 if (!regReq.getPassword().isEmpty()) { 19 if (!regReq.isPasswordEqualToConfirmPassword()) { 20 errors.rejectValue("confirmPassword", "nomatch"); 21 } 22 } 23} Print Error Message 1<form:errors path="email" /> ๋ง์ฝ errors.rejectValue(“email”, “requireed”) ์ฝ๋๋ก ์๋ฌ์ฝ๋๋ฅผ ์ถ๊ฐํ๊ณ ์ปค๋งจ๋ ๊ฐ์ฒด๊ฐ registerRequest์ธ ๊ฒฝ์ฐ, required.registerRequest.eail required.email required.String required ์์ ๊ฐ์ ์์๋๋ก ๋ฉ์์ง ์ฝ๋๋ฅผ ๊ฒ์ํ๋ค. Global scoped validate MvcConfig.java 1@Override 2public Validator getValidator() { 3 return new RegisterRequestValidator(); 4} RegisterController.java 1@PostMapping("/register/step3") 2public String handleStep3(@Valid RegisterRequest regReq, Errors errors) { 3 if (errors.hasErrors()) 4 return "register/step2"; global ๋ฒ์ validator๋ฅผ ์ฌ์ฉํ ์ ์๋ค. Controller scoped validate RegisterController.java 1@InitBinder 2protected void initBinder(WebDataBinder binder) { 3 binder.setValidator(new RegisterRequestValidator()); 4} ์ฐ์ ์์ setValidator() : controller scoped validator ์ ์ฉ addValidator() : global scoped validator ์ ์ฉ ํ controller scoped validator ์ ์ฉ Bean validation RegisterRequest.java 1import javax.validation.constraints.Size; 2 3import org.hibernate.validator.constraints.Email; 4import org.hibernate.validator.constraints.NotBlank; 5import org.hibernate.validator.constraints.NotEmpty; 6 7public class RegisterRequest { 8 @NotBlank 9 @Email 10 private String email; 11 @Size(min = 6) 12 private String password; 13 @NotEmpty 14 private String confirmPassword; 15 @NotEmpty 16 private String name; bean validation์ ์ฌ์ฉํ๊ธฐ ์ํด
org.hiberante dependency๋ฅผ ์ถ๊ฐํด์ผํ๋ค
๊ธฐ์กด์ ์๋ Validator๋ฅผ ์์ ๋์ด์ผํ๋ค
๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์ด๊ฑฐ ์จ์ validator ์ง์ ์งค ์ผ์ ์์ ๊ฒ ๊ฐ๋ค. ์ 1์ฅ : ์๋ฃ๊ตฌ์กฐ๋ฅผ ๋ฐฐ์ฐ๊ธฐ ์ํ ์ค๋น (230302) ๋ฐฐ์ด ๋ฐฐ์ด(Array): ๋์ผํ ํ์
์ ์์๋ค์ด ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น๋์ด ์๋ ๊ธฐ์ด์ ์ธ ์๋ฃ๊ตฌ์กฐ ์ถ์๋ฐ์ดํฐ ํ์
์ถ์๋ฐ์ดํฐํ์
(ADT:Abstract Data Type) : ๋ฐ์ดํฐ์ ๊ทธ ๋ฐ์ดํฐ์ ๋ํ ์ถ์์ ์ธ ์ฐ์ฐ๋ค๋ก์จ ๊ตฌ์ฑ ADT =~ ์๋ฐ์ interface, ์๋ฃ๊ตฌ์กฐ =~ ์๋ฐ์ class ์๋ฃ๊ตฌ์กฐ๋ ์ถ์๋ฐ์ดํฐํ์
์ ๊ตฌ์ฒด์ ์ผ๋ก ๊ตฌํํ ๊ฒ 1-2 ์ํ์๊ฐ์ ๋ถ์ ์๊ณ ๋ฆฌ์ฆ์ ์ฑ๋ฅ: ์ํ์๊ฐ์ ๋ํ๋ด๋ **์๊ฐ๋ณต์ก๋(Time Complexity)**์ ์๊ณ ๋ฆฌ์ฆ์ด ์ํ๋๋ ๋์ ์ฌ์ฉ๋๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํฌ๊ธฐ๋ฅผ ๋ํ๋ด๋ **๊ณต๊ฐ๋ณต์ก๋(Space Complexity)**์ ๊ธฐ๋ฐํ์ฌ ๋ถ์ ์๊ฐ ๋ณต์ก๋
์๊ฐ๋ณต์ก๋๋ ์๊ณ ๋ฆฌ์ฆ(์ฐ์ฐ)์ด ์คํ๋๋ ๋์์ ์ฌ์ฉ๋ ๊ธฐ๋ณธ์ ์ธ ์ฐ์ฐ ํ์๋ฅผ ์
๋ ฅ ํฌ๊ธฐ์ ํจ์๋ก ๋ํ๋ธ๋ค. ๊ธฐ๋ณธ ์ฐ์ฐ(Elementary Operation)์ด๋ ๋ฐ์ดํฐ ๊ฐ ํฌ๊ธฐ ๋น๊ต, ๋ฐ์ดํฐ ์ฝ๊ธฐ ๋ฐ ๊ฐฑ์ , ์ซ์ ๊ณ์ฐ ๋ฑ๊ณผ ๊ฐ์ ๋จ์ํ ์ฐ์ฐ์ ์๋ฏธ 4๊ฐ์ง ์ข
๋ฅ์ ๋ถ์
์ต์
๊ฒฝ์ฐ ๋ถ์(Worst-case Analysis) : ์ํ์ ์ ์๋ฏธ ํ๊ท ๊ฒฝ์ฐ ๋ถ์(Average-case Analysis) ์ต์ ๊ฒฝ์ฐ ๋ถ์(Best-case Analysis) : ๊ฐ์ฅ ๋น ๋ฅธ ์ํ์๊ฐ ์๊ฐ๋ถ์(Amortized Analysis) : ์ด ์ฐ์ฐํ์๋ฅผ ํฉํ๊ณ ์ฐ์ฐ ํ์๋ก ๋๋์ด ์ํ์๊ฐ์ ๋ถ์ 1-3 ์ํ์๊ฐ์ ์ ๊ทผํ๊ธฐ๋ฒ O (Big-Oh)-ํ๊ธฐ๋ฒ ฮฉ (Big-Omega)-ํ๊ธฐ๋ฒ ฮ (Theta)-ํ๊ธฐ๋ฒ O (Big-Oh) ํ๊ธฐ๋ฒ ๋ชจ๋ N โฅ N0์ ๋ํด์ f(N) โค cg(N)์ด ์ฑ๋ฆฝํ๋ ์์ ์์ c์N0๊ฐ ์กด์ฌํ๋ฉด, f(N) = O(g(N))์ด๋ค. ๋ชจ๋ N โฅ N0์ ๋ํด์ f(N) โค cg(N)์ด ์ฑ๋ฆฝํ๋ ์์ ์์ c์ N0๊ฐ ์กด์ฌํ๋ฉด, f(N) = O(g(N)) f(N) = O(g(N))์ N0 ๋ณด๋ค ํฐ ๋ชจ๋ N ๋ํด์ f(N)์ด ์์ ์์๋ฅผ ๊ณฑํ g(N)์ ๋ฏธ์น์ง ๋ชปํ๋ค๋ ๋ป g(N)์ f(N)์ ์ํ(Upper Bound) ์ด๋ผ๊ณ ํ๋ค ฮฉ (Big-Omega) ํ๊ธฐ๋ฒ ๋ชจ๋ N โฅ N0์ ๋ํด์ f(N) โฅ cg(N)์ด ์ฑ๋ฆฝํ๋ ์์ ์์ c์ N0๊ฐ ์กด์ฌํ๋ฉด, f(N) = ฮฉ(g(N)) f(N) = ฮฉ(g(N))์ ์์ ์์๋ฅผ ๊ณฑํ g(N)์ด f(N)์ ๋ฏธ์น์ง ๋ชปํ๋ค๋ ๋ป g(N)์ f(N)์ ํํ(Lower Bound) ์ด๋ผ๊ณ ํ๋ค ฮ (Theta) ํ๊ธฐ๋ฒ ๋ชจ๋ N โฅ N0์ ๋ํด์ c1g(N) โฅ f(N) โฅ c2g(N)์ด ์ฑ๋ฆฝํ๋ ์์ ์์ c1, c2, N0๊ฐ ์กด์ฌํ๋ฉด, f(N) = ฮ(g(N)) ฮ-ํ๊ธฐ๋ ์ํ์๊ฐ์ O-ํ๊ธฐ์ ฮฉ-ํ๊ธฐ๊ฐ ๋์ผํ ๊ฒฝ์ฐ์ ์ฌ์ฉ ์์ฃผ ์ฌ์ฉ๋๋ ํจ์์ O-ํ๊ธฐ์ ์ด๋ฆ O(1), O(logN), O(N), O(NlogN), O(N2), O(N3), O(2N) 1-5 ์ํ (Recursion) ์ํ์ผ๋ก ๊ตฌํ๋ ๋ฉ์๋์ ๊ตฌ์ฑ์์ ๊ธฐ๋ณธ(Base) case : ์ค์ค๋ก๋ฅผ ๋ ์ด์ ํธ์ถํ์ง ์๋ ๋ถ๋ถ ์ํ case : ์ค์ค๋ก๋ฅผ ํธ์ถํ๋ ๋ถ๋ถ ๊ผฌ๋ฆฌ ์ํ (Tail Recursion) ๋ฉ์๋์ ๋ง์ง๋ง ๋ถ๋ถ์์ ์ํ (ํธ์ถ ํ ๋๋์ ์์๋ ์ํํ ์ฐ์ฐ์ด ์๋ ๊ฒฝ์ฐ) ๊ผฌ๋ฆฌ ์ํ์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋ณํํ๋ ๊ฒ์ด ํจ์จ์ ์ด๋ค 1public class TailRecursion { 2 public static int factorial(int n, int fact) { 3 if (n==1) 4 return fact; 5 return factorial( ,); 6 } 7} ์ 2์ฅ : ๋ฆฌ์คํธ ๋ฆฌ์คํธ ์ผ๋ จ์ ๋์ผํ ํ์
์ ํญ๋ชฉ๋ค์ด ๋์ด๋ ๊ฒ ๋ฐฐ์ด ๋์ผํ ํ์
์ ์์๋ค์ด ์ฐ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ํ ๋น๋์ด ๊ฐ ํญ๋ชฉ์ด ํ๋์ ์์์ ์ ์ฅ๋๋ ๊ธฐ๋ณธ์ ์ธ ์๋ฃ๊ตฌ์กฐ ์ ๊ทผ : O(1), ์ฝ์
/์ญ์ : O(n) ๋ฐฐ์ด๋ก ๋ฆฌ์คํธ ๊ตฌํ (ArrList) peek, insert, resize, delete ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Singly Linked List) print, search, insertFront, insertAfter ์๊ธฐ์ฐธ์กฐ๋ณ์ 1public class Node <E> { 2 private Node<E> next; // ์๊ธฐ ์ฐธ์กฐ ๋ณ์ 3 ... 4} ์ํ์๊ฐ search : O(n) insert, delete : O(1), p๊ฐ ์์ฃผ์ด์ง๋ฉด O(n) ์ด์ค ์ฐ๊ฒฐ ๋ฆฌ์คํธ (Doubly Linked List) head, tail, item insertBefore, insertAfter, delete, ์ํ์๊ฐ ์ฝ์
/์ญ์ ์ฐ์ฐ : O(1) ํ์ ์ฐ์ฐ : O(n) ์ํ ์ฐ๊ฒฐ ๋ฆฌ์คํธ(Circular Linked List) ์ํ์๊ฐ ์ฝ์
/์ญ์ ์ฐ์ฐ : O(1) ํ์ ์ฐ์ฐ : O(n) ์ 3์ฅ : ์คํ๊ณผ ํ ์คํ ๋ฐฐ์ด๋ก ๊ตฌํ / LinkedList๋ก ๊ตฌํ ํ์ ํ๊ธฐ <-> ์ค์ ํ๊ธฐ ์ํ์๊ฐ push, pop : O(1) ๋ฐฐ์ด ํฌ๊ธฐ์ ํ๋/์ถ์ : O(n) ๋จ์ ์ฐ๊ฒฐ ๋ฆฌ์คํธ์ pop, push : O(1) ์ 4์ฅ : ํธ๋ฆฌ ์ฉ์ด root, parent, child leaf, sibling, ancesto๋ฆฌ(์กฐ์), descendant(ํ์) subtree(๋
ธ๋ ์์ ๊ณผ ํ์์ผ๋ก ๊ตฌ์ฑ๋ ํธ๋ฆฌ) degree(์ฐจ์ : ์์ ์) level (๊น์ด์ ๋์ผ, 0 ๋๋ 1๋ถํฐ ์์) height (ํธ๋ฆฌ์ ์ต๋ level) key (ํ์์ ์ฌ์ฉ๋๋ ๋
ธ๋์ ์ ์ฅ๋ ์ ๋ณด) ์ผ์ชฝ ์์-์ค๋ฅธ์ชฝ ํ์ (Left Child-Right Sibling) ํํ ๋
ธ๋์ ์ผ์ชฝ ์์๊ณผ ์ค๋ฅธ์ชฝ ํ์ ๋ฅผ ๊ฐ๋ฆฌํค๋ 2๊ฐ์ ๋ ํผ๋ฐ์ค๋ง ์ฌ์ฉ ์ด์ง ํธ๋ฆฌ (Binary Tree) ๊ฐ ๋
ธ๋์ ์์ ์๊ฐ 2 ์ดํ์ธ ํธ๋ฆฌ ํน๋ณํ ํํ์ ์ด์งํธ๋ฆฌ
ํฌํ ์ด์ง ํธ๋ฆฌ(Perfect Binary Tree) ๊ฐ ๋ด๋ถ ๋
ธ๋๊ฐ 2๊ฐ์ ์์์ ๊ฐ์ง๊ณ ๋ชจ๋ ์ดํ๋ฆฌ๊ฐ ๊ฐ์ ์ธต์ ์๋ ํธ๋ฆฌ ์์ ์ด์ง ํธ๋ฆฌ(Complete Binary Tree) ๋ง์ง๋ง ๋ ๋ฒจ์ ์ ์ธํ ๊ฐ ๋ ๋ฒจ์ด ๋
ธ๋๋ค๋ก ๊ฝ ์ฐจ์๊ณ , ๋ง์ง๋ง ๋ ๋ฒจ์๋ ๋
ธ๋๋ค์ด ์ผ์ชฝ๋ถํฐ ๋น ์ง์์ด ์ฑ์์ง ํธ๋ฆฌ ์ด์ง ํธ๋ฆฌ์ ์์ฑ
๋ ๋ฒจ k์ ์๋ ์ต๋ ๋
ธ๋ ์ = $2^{k-1}$ ๋์ด๊ฐ h์ธ ํฌํ ์ด์ง ํธ๋ฆฌ์ ์๋ ๋
ธ๋ ์ = $2^{h}-1$ n๊ฐ์ ๋
ธ๋๋ฅผ ๊ฐ์ง ์์ ์ด์ง ํธ๋ฆฌ์ ๋์ด = $log_{2}(n+1)$ ๋์ด๊ฐ h์ธ ์์ ์ด์งํธ๋ฆฌ์ ์กด์ฌํ ์ ์๋ ๋
ธ๋ ์ n ๋ฐฐ์ด์ ์ ์ฅ๋ ์ด์ง ํธ๋ฆฌ
ํธ๋ฆฌ
1A 2โโโ B 3โ โ-โ D 4โ โ โโโ H 5โ โ โโโ I 6โ โ-โ E 7โ โโโ J 8โ โโโ K 9โโโ C 10 โโโ F 11 โโโ G ์ ํธ๋ฆฌ๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ๋ฉด (์ธ๋ฑ์ค 1๋ถํฐ ์์)
1A = [A, B, C, D, E, F, G, H, I, J, K] a[i]์ ๋ถ๋ชจ๋ a[i/2], ๋จ i>1 a[i]์ ์ผ์ชฝ ์์์ a[2i], ๋จ 2i <= n a[i]์ ์ค๋ฅธ์ชฝ ์์์ a[2i+1], ๋จ 2i+1 <= n ํธํฅ(skewed) ์ด์ง ํธ๋ฆฌ
๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ฐ ์ฌํ๋ค ์ด์ง ํธ๋ฆฌ์ ์ํ preorder ; root - left - right inorder : left - root - right postorder : left - right - root levelorder : left -> right (from top level)
์ํ ์๊ฐ O(n) ์๊ฐ์ด ์์ ์งํฉ์ ํํ ๋ฐฐ์ด index 0 1 2 3 4 5 6 7 8 9 value 4 2 7 7 4 4 2 7 7 4 ์งํฉ 1 17 2โโโ 2 3โ โ-โ 1 4โ โ-โ 6 5โโโ 8 6โโโ 3 ์งํฉ2 14 2โโโ 0 3โโโ 5 4โโโ 9 ์ํ ์๊ฐ union : O(N) find : O(N) ์ 5์ฅ : ํ์ ํธ๋ฆฌ 5.1 ์ด์งํ์ํธ๋ฆฌ min ํจ์ deleteMin ํจ์ delete ํจ์ CASE 1 : ์ญ์ ํ ๋
ธ๋์ ๋ ์์์ด ๋ชจ๋ null CASE 2 : ์ญ์ ํ ๋
ธ๋์ ์ค๋ฅธ์ชฝ ์์๋ง null CASE 3 : ์ญ์ ํ ๋
ธ๋์ ์ผ์ชฝ ์์๋ง null CASE 4 : ์ญ์ ํ ๋
ธ๋์ ์์์ด ๋๋ค ์กด์ฌ ์๊ฐ ๋ณต์ก๋ O($logn$) 5.2 AVL ํธ๋ฆฌ AVLํธ๋ฆฌ์ ์ ์ ์์์ ๋
ธ๋ x์ ๋ํด x์ ์ผ์ชฝ ์๋ธํธ๋ฆฌ์ ์ค๋ฅธ์ชฝ ์๋ธํธ๋ฆฌ์ ๋์ด ์ฐจ์ด๊ฐ 1์ ๋์ง ์๋ ์ด์ง ํ์ ํธ๋ฆฌ
AVLํธ๋ฆฌ์ ํ์ ์ฐ์ฐ LL ํ์ : ์ผ์ชฝ์ผ๋ก ์น์ฐ์น ๊ฒฝ์ฐ rotateRight(n)๋ฅผ ํตํด ํด๊ฒฐ RR ํ์ : ์ค๋ฅธ์ชฝ์ผ๋ก ์น์ฐ์น ๊ฒฝ์ฐ rotateLeft(n)๋ฅผ ํตํด ํด๊ฒฐ LR ํ์ : rotateLeft(n.left) -> rotateRight(n)๋ก ํด๊ฒฐ RL ํ์ : rotateRight(n.right) -> rotateLeft(n)๋ก ํด๊ฒฐ 4๊ฐ์ง ํ์ ์ ๊ณตํต์ ํ์ ํ์ ํธ๋ฆฌ๋ค์ด ๋ชจ๋ ๊ฐ๋ค, ๋ชจ๋ O(1)
AVLํธ๋ฆฌ์ ์ฐ์ฐ ์ฝ์
์ฐ์ฐ ์ด์ง ํธ๋ฆฌ์ ์ฝ์
๊ณผ ๋์ผํ๊ฒ ์ ๋
ธ๋ ์ฝ์
์ ๋
ธ๋๋ก๋ถํฐ ๋ฃจํธ๋ก ๊ฑฐ์ฌ๋ฌ ์ฌ๋ผ๊ฐ๋ฉฐ ๋ถ๊ท ํ์ด ๋ฐ์ํ๋ฉด ์ ์ ํ๊ฒ ํ์ ์ฐ์ฐ ์ํ ์ญ์ ์ฐ์ฐ 5.3 2-3 ํธ๋ฆฌ 2-3 ํธ๋ฆฌ์ ์ ์ ์์์ ๋
ธ๋๊ฐ 2๊ฐ ๋๋ 3๊ฐ์ ์์์ ๊ฐ์ง ์ ์๋ ํธ๋ฆฌ๋ก, ๋ชจ๋ ๋ฆฌํ ๋
ธ๋๊ฐ ๊ฐ์ ๋ ๋ฒจ์ ์๋ค.
2-3 ํธ๋ฆฌ์ ์ฐ์ฐ ํ์ ์ฐ์ฐ ์ด์ง ํ์ ํธ๋ฆฌ์ ๋์ผํ ๋ฐฉ๋ฒ์ผ๋ก ํ์
๋ถ๋ฆฌ ์ฐ์ฐ ํค๋ฅผ ๋ถ๋ชจ๋ก ์ฌ๋ ค ๋ณด๋
๋ถ๋ชจ๊ฐ 3-๋
ธ๋์ด๋ฉด ๋ค์ ๋ถ๋ฆฌ์ฐ์ฐ ์ํ
๋ฃจํธ์์ ์ผ์ด๋๋ฉด ํธ๋ฆฌ์ ๋์ด 1 ์ฆ๊ฐ
์ฝ์
์ฐ์ฐ ์ฝ์
ํ ๋ถ๋ฆฌ ์ฐ์ฐ์ ์ํ
์ญ์ ์ฐ์ฐ ์ญ์ ํ ๋
ธ๋๊ฐ ์ดํ๋ฆฌ ๋
ธ๋์ด๋ฉด ๊ทธ๋ฅ ์ญ์
์ญ์ ํ ๋
ธ๋๊ฐ ์ดํ๋ฆฌ ๋
ธ๋๊ฐ ์๋๋ผ๋ฉด ๊ตํ ํ ์ญ์ ์ด๋ ์ฐ์ฐ, ํตํฉ ์ฐ์ฐ ์ฌ์ฉ
์ด๋ ์ฐ์ฐ ๋น ์๋ฆฌ๋ฅผ ํ์ ์ ๋ฐ๊พผ๋ค
์ด๋์ฐ์ฐ์ด ๋ถ๊ฐ๋ฅํ๋ฉด ํตํฉ ์ฐ์ฐ ์ํ
ํตํฉ ์ฐ์ฐ ์ญ์ ํ ๋
ธ๋์ ๋ถ๋ชจ์ ํ์ ๋ฅผ ํตํฉํ๋ค
2-3 ํธ๋ฆฌ์ ์ํ์๊ฐ ํ์, ์ฝ์
, ์ญ์ ์ฐ์ฐ -> O($logn$) -> ํธ๋ฆฌ์ ๋์ด์ ๋น๋ก ๋ถ๋ฆฌ ์ฐ์ฐ, ํตํฉ ์ฐ์ฐ -> O(1) 2-3ํธ๋ฆฌ๊ฐ ๊ฐ์ฅ ๋์ ๊ฒฝ์ฐ ๋ชจ๋ ๋
ธ๋๊ฐ 2-๋
ธ๋์ธ ๊ฒฝ์ฐ ๋์ด : $ log_2(n+1) $
2-3ํธ๋ฆฌ๊ฐ ๊ฐ์ฅ ๋ฎ์ ๊ฒฝ์ฐ ๋ชจ๋ ๋
ธ๋๊ฐ 3-๋
ธ๋์ธ ๊ฒฝ์ฐ ๋์ด : $ log_3(n) $
5.4 2-3-4 ํธ๋ฆฌ 2-3ํธ๋ฆฌ๋ฅผ ํ์ฅํ 2-3-4 ํธ๋ฆฌ๋ ๋
ธ๋๊ฐ ์์์ 4๊ฐ๊น์ง ๊ฐ์ง ์ ์๋ ์์ ๊ท ํํธ๋ฆฌ
์ด๋ก ์ ์ผ๋ก๋ 2-3ํธ๋ฆฌ์ ๋์ผํ๋ค ์ค์ ๋ก๋ ๋ ๋น ๋ฆ 5.5 B-ํธ๋ฆฌ B-ํธ๋ฆฌ์ ์ ์ ๋ค์์ ํค๋ฅผ ๊ฐ์ง ๋
ธ๋๋ก ๊ตฌ์ฑ๋์ด ๋ค๋ฐฉํฅ ํ์์ด ๊ฐ๋ฅํ ๊ท ํํธ๋ฆฌ
B-ํธ๋ฆฌ์ ์ฐ์ฐ ํ์ ์ฐ์ฐ ๋ฃจํธ ๋ถํฐ ์์ ๊ฐ ๋
ธ๋์์ ์ด์ง ํ์ ์ํ
์ฝ์
์ฐ์ฐ ์ดํ๋ฆฌ์ ์ ํค๋ฅผ ์์ฉํ ๊ณต๊ฐ์ด ์๋ค๋ฉด, ์ ๋ ฌ๋ ์ํ๋ฅผ ์ ์งํ๋๋ก ์ฝ์
์ด๋ฏธ M-1๊ฐ์ ํค๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉด, ๋ถ๋ฆฌ ์ฐ์ฐ์ ์ํ
์ญ์ ์ฐ์ฐ ์ญ์ ํ ๋
ธ๋๊ฐ ์ดํ๋ฆฌ ๋
ธ๋์ด๋ฉด ๊ทธ๋ฅ ์ญ์ ์ญ์ ํ ๋
ธ๋๊ฐ ์ดํ๋ฆฌ ๋
ธ๋๊ฐ ์๋๋ผ๋ฉด ๊ตํ ํ ์ญ์ ์ด๋ ์ฐ์ฐ, ํตํฉ ์ฐ์ฐ ์ฌ์ฉ
์ด๋ ์ฐ์ฐ ํค์ ์๊ฐ M/2-1๋ณด๋ค ์์ผ๋ฉด(underflow) ํ์ , ๋ถ๋ชจ๋
ธ๋๋ฅผ ์ด๋ฅ ์ด๋ ์ฐ์ฐ์ด ๋ถ๊ฐ๋ฅํ๋ฉด ํตํฉ ์ฐ์ฐ ์ํ
ํตํฉ ์ฐ์ฐ ์ญ์ ํ ๋
ธ๋์ ๋ถ๋ชจ์ ํ์ ๋ฅผ ํตํฉํ๋ค
B-ํธ๋ฆฌ์ ์ํ์๊ฐ ํ์, ์ฝ์
, ์ญ์ ์ฐ์ฐ -> O($log_{M/2}n$) -> ํธ๋ฆฌ์ ๋์ด์ ๋น๋ก ์ 6์ฅ : ํด์ ํ
์ด๋ธ ๋ํ์ ์ธ ํด์ ํจ์ ์ค๊ฐ ์ ๊ณฑ ํจ์ : ํค๋ฅผ ์ ๊ณฑํ ํ, ์ ์ ํ ํฌ๊ธฐ์ ์ค๊ฐ ๋ถ๋ถ์ ์ฌ์ฉ ์ ๊ธฐ ํจ์ : ํค๋ฅผ ์ฌ๋ฌ ๋ถ๋ถ์ผ๋ก ๋๋ ํ, ์ด๋ค์ ๋ํ ๊ฐ์ ์ฌ์ฉ ์๋ฐ์ hashCode() 1private int hash(Key k) { 2 return (k.hashCode() & 0x7fffffff) % M; 3} ํด์ ํ
์ด๋ธ์ ์ ์ฅ ๋ฐฉ์ ๊ฐ๋ฐฉ ์ฃผ์ ๋ฐฉ์ : ์ถฉ๋๋ ํค๋ฅผ ์ผ์ ํ ๋ฐฉ์์ ๋ฐ๋ผ ์ฐพ์๋ธ empty์์์ ์ ์ฅ ์ ํ ์กฐ์ฌ, ์ด์ฐจ์กฐ์ฌ, ์ด์คํด์ฑ ์ ํ ์กฐ์ฌ : ์ถฉ๋์ด ์ผ์ด๋ ๊ณณ์ผ๋ก๋ถํฐ ์์ฐจ์ ์ผ๋ก ํ์ 1์ฐจ ๊ตฐ์งํ (ํค๋ค์ด ๋ญ์ณ์ง๋ ํ์) ๋ฐ์ ๊ตฐ์งํ๋ ๊ตฐ์ง๋ ํค๋ค์ ์์ฐจ์ ์ผ๋ก ๋ฐฉ๋ฌธํด์ผํ๋ ๋ฌธ์ ์ ์ ์ผ์ผํจ๋ค ์ 7์ฅ : ์ฐ์ ์์ ํ ์ฐ์ ์์ ํ (Priority Queue) ๊ฐ์ฅ ๋์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง ํญ๋ชฉ์ ์ ๊ทผ๊ณผ ์ญ์ , ์์์ ์ฐ์ ์์๋ฅผ ๊ฐ์ง ํญ๋ชฉ์ ์ฝ์
์ ์ง์ํ๋ ์๋ฃ๊ตฌ์กฐ ํ (Heap) ์์ ์ด์ง ํธ๋ฆฌ๋ก์ ๋ถ๋ชจ์ ์ฐ์ ์์๊ฐ ์์์ ์ฐ์ ์์๋ณด๋ค ๋์ ์๋ฃ๊ตฌ์กฐ ์ต์ ํ, ์ต๋ ํ ํ์ ์ฐ์ฐ ์ต์๊ฐ ์ญ์ ๋ฃจํธ ์ญ์ ํ, ๋ง์ง๋ง ๋
ธ๋๋ฅผ ๋ฃจํธ๋ก ์ด๋ downheap ์ํ : ๋ฃจํธ๋ถํฐ ๋น๊ตํ๋ฉด์ ๋ด๋ ค๊ฐ ์ฝ์
๋ง์ง๋ง ํญ๋ชฉ์ ๋ค์์ ์ฝ์
upheap ์ํ : ๋ฃจํธ๋ก ๋น๊ตํ๋ฉด์ ์ฌ๋ผ๊ฐ ์ํฅ์ ํ 1public void createHeap() { 2 for (int i = N/2; i>0; i--) { 3 downheap(i); 4 } 5} O(n) ์ํ ์๊ฐ ์ ๊ทผ, ์ฝ์
, ์ญ์ : O(logn) ์ 8์ฅ : ์ ๋ ฌ ์ ํ ์ ๋ ฌ (Selection Sort) ํญ์ O(n^2) ์ฝ์
์ ๋ ฌ (Insertion Sort) ์ต์
: O(n^2) ์ต์ : O(n) : ์ด๋ฏธ ์ ๋ ฌ๋ ๊ฒฝ์ฐ ํ ์ ๋ ฌ (Heap Sort) ํญ์ : O(nlogn) ํฉ๋ณ ์ ๋ ฌ (Merge Sort) ํญ์ : O(nlogn) Stable Sort : ๊ฐ์ ๊ฐ์ ํค๋ฅผ ๊ฐ์ง ๋ ์ฝ๋์ ์์๊ฐ ์ ๋ ฌ ํ์๋ ์ ์ง๋๋ ์ ๋ ฌ ํต ์ ๋ ฌ (Quick Sort) ์ต์
: O(n^2)
์ต์ : O(nlogn)
์ฑ๋ฅ ํฅ์ ๋ฐฉ๋ฒ
Median of Three : ์ฒซ๋ฒ์งธ, ๋ง์ง๋ง, ์ค๊ฐ๊ฐ ์ค์์ ์ค๊ฐ๊ฐ์ ํผ๋ฒ์ผ๋ก ์ ํ ์
๋ ฅ์ด ์์ ํฌ๊ธฐ๊ฐ ๋์์๋ ์ฝ์
์ ๋ ฌ์ ์ฌ์ฉ ์ด์์ฒด์ ๊ฐ์ ์ด์์ฒด์ ์ ์ญํ Program execution Access to computer resources (I/O device, Data…) Error detection and response Accounting (ex: task manager) ์ด์์ฒด์ ์ ๋ฐ์ Serial Processing : No OS, No Job scheduling
Simple batch system
OS๊ฐ job์ ํ ๋น Controlled by monitor Uni-programming
๋ค ์คํ๋ ๋๊น์ง ๊ธฐ๋ค๋ฆผ bad utilization Multiprogramming
The processor can switch to the other job better utilization, needs more memory Time sharing
proceess์๊ฒ ์ ํด์ง time slice (time quantum)๊ฐ ์ฃผ์ด์ง๋ค. better utilization, bad throughput Symmetric multiprocessing (SMP)
์ฌ๋ฌ processors๊ฐ main memory, I/O ์ฅ์น๋ค์ ๊ณต์ ์ฌ๋ฌ processors๊ฐ ๋์ผํ function ์ํ ๊ฐ๋ฅ ์ด์์ฒด์ ์ ๊ตฌ์ฑ ์์ Distributed Systems (๋ถ์ฐ์์คํ
) ์ฌ๋ฌ ์ปดํจํฐ๋ฅผ ์ฐ๊ฒฐํด ์ฌ์ฉ ๋น ๋ฅธ ์๋, ๋์ ๋ฐ์ดํฐ ๊ฐ์ฉ์ฑ Command-Interpreter System user๊ฐ ์ง์ OS์๊ฒ ์ผ์ ์ํจ๋ค OS Architecture Monolithic kernel ๋ชจ๋ OS์ ๊ธฐ๋ฅ์ ํ๋์ kernel์ด ๊ฐ์ง๊ณ ์๋๋ค ํ๋ ์์ ํ๋ฉด ์ ์ฒด๋ฅผ ์ปดํ์ผ ํด์ผ ํ๋ค Microkernel kernel kernel ๋ด์ ํ์ํ ๊ธฐ๋ฅ Address space management, Interprocess communication, ๊ธฐ๋ณธ์ ์ธ ํ๋ก์ธ์ค scheduling ๊ธฐ๋ฅ
kernel๊ฐ ํต์ ์๋๊ฐ ๋๋ฆฌ๋ค Process Process๋ ์ปดํจํฐ์์ ์คํ ์ค์ธ ๊ฐ์ฒด register ์ค PC๊ฐ context๋ฅผ ๊ฐ๋ฆฌํจ๋ค Context๋ data์ code๋ก ๊ตฌ์ฑ Trace of Processes A -> time out -> B -> I/O request -> A ์ฌ์ด์ฌ์ด์ dispatcher๊ฐ processor์ process๋ฅผ ๊ต์ฒดํ๋ค Process state model Process suspension์ ์ด์ Swapping : memory ๊ณต๊ฐ ํ๋ณด๋ฅผ ์ํด Timing : ์ฃผ๊ธฐ์ ์ผ๋ก ์คํ๋๋ ํ๋ก๊ทธ๋จ Interactive user request : user์ ์์ฒญ Parent process request : parent process์ ์์ฒญ Process Control block ๊ตฌ์ฑ์์ : Identifier, State, Priority, PC, Memory pointers, Address of memory context, I/O state info, Accounting info Process 1๊ฐ ๋น PCB 1๊ฐ Process Context User Context : code, data, user stack System Context : kernel stack, PCB Virtual Address Space ํ๋ก์ธ์ค๊ฐ ์คํ๋๋ฉด ์ ์ ๊ทผ(access, reference) ๊ฐ๋ฅํ ์ฃผ์๋ค์ ๋ฒ์
32bit address computer : $2^{32}$ = 4G ๋ฒ์ง, 3G~4G๋ฒ์ง์๋ ์ปค๋์ด ๋ค์ด๊ฐ๋ค
๋ณด์กฐ๊ธฐ์ต์ฅ์น์ VAS๋ ํ๋ก์ธ์ค ๊ฐ์๋งํผ ์กด์ฌ
๊ตฌ์ฑ
| kernel | stack (local var) | bss (๋ง๋ค๋ ์ด๊ธฐํ ์ ํ global var) | data (๋ง๋ค๋ ์ด๊ธฐํ ํ global var) | code Process Creation Process๊ฐ ์์ฑ๋๋ ๊ฒฝ์ฐ
OS๊ฐ ๋ง๋๋ ๊ฒฝ์ฐ ์คํ ์ค์ธ process๊ฐ ์์์ ๋ง๋๋ ๊ฒฝ์ฐ User command fork()
์์ ํ๋ก์ธ์ค์ memory infotable์ด ๋ถ๋ชจ์ context๋ฅผ ๊ฐ๋ฆฌํค๊ฒ ํ๋ค memory๋ด์์ ๋ถ๋ชจ์ data, stack์ ๋ณต์ ํ๋ค ์์์ด ๊ฐ๋ฆฌํค๋ ๊ฒ์ ๋ณต์ ๋ context๋ก ๋ฐ๊พผ๋ค COW(Copy on write) : ๋ณต์ฌ๋ฅผ ๋ฆ์ถค์ผ๋ก์ ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ Process switch Mode change : Memory ๋ด์์ user mode <-> system mode Context change : ๋ค๋ฅธ process๋ก switch Context change๋ฅผ ํ๋ ๊ฒฝ์ฐ
Process์ ์๋ฉธ : Running -> Release Process์ block (I/O request, file open, page fault) : Running -> Blocked Expiration of time slice : Running -> Ready I/O interrupt : Blocked -> Ready Steps of context switch
Save context(pc, other register) of processor Update the PCB Move PCB to appropriate queue Select another process to execute Update the PCB Update memory-management data structures Restore context of the selected process Process Termination Process๊ฐ ์ญ์ ๋๋ ๊ฒฝ์ฐ Normal ompletion Parent request Protection error : ๋น์ ์์ ์ธ ์ ๊ทผ์ ํ ๋ OS๊ฐ ๊ฐ์ ์ข
๋ฃ Arithmetic Error, Invalid instruction… terminated ์ํ : Computer resource๋ ๋บ๊ฒผ์ง๋ง, PCB๋ ๋จ์์๋ ์ํ ํด๋น ํ๋ก์ธ์์ ๋ถ๋ชจ ํ๋ก์ธ์ค๊ฐ wait syscall์ ํธ์ถํ๋ฉด ์์ ํ ์ญ์ ์ง์์ง๋ ๋ถ๋ชจ ๋ฐ์ ์์์ด ๋จ์์๋ค๋ฉด ์์๋ค์ init ํ๋ก์ธ์ค์ ์์๋ก ๋ณด๋ธ๋ค Inter-Process Communication (IPC) Message Passing : kernel๋ด mailbox๋ฅผ ํตํด ๋ฉ์์ง๋ฅผ ์ฃผ๊ณ ๋ฐ๋ ๋ฐฉ๋ฒ user mode -> kernel mode -> user mode ๊ตฌํ์ด ์ฝ๋ค, ๋๋ฆฌ๋ค Shared Memory VAD์ shared memory๋ฒ ์ฃผ์๋ฅผ ๊ฐ๊ณ ์๋ค ๋น ๋ฅด๋ค, ๊ตฌํ์ด ์ด๋ ต๋ค Message / Signal Threads Process์ Thread์ ์ฐจ์ด Thread๋ A unit of execution of in a process
has an execution state
๊ตฌ์ฑ ์์
Stack Memory for registers context : thread control block multithread
Thread์ ์ฅ์ Process ๋ง๋๋๊ฑฐ ๋ณด๋ค Thread ๋ง๋๋๊ฒ ๋น ๋ฅด๋ค Process ์์ ๋๊ฑฐ ๋ณด๋ค Thread ์์ ๋๊ฒ ๋น ๋ฅด๋ค Process๋ผ๋ฆฌ ํต์ ํ๋๊ฑฐ๋ณด๋ค Thread๋ผ๋ฆฌ ํต์ ์ด ๋ ๋น ๋ฅด๋ค (data ๊ณต์ ) User-Level Threads mode change๊ฐ ํ์์๋ค user๊ฐ control ํ ์ ์๋ค ํ๋๊ฐ block๋๋ฉด ๋๋จธ์ง๋ block (kernel ์
์ฅ์์ 1๊ฐ์ thread) Kernel-Level Threads kernel์ ์ข
์์ ์ด๋ค kernel์ด ๊ฐ๋ณ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์๋ค Mutual Exclusion and Synchronization Key terms in Concurrency Race condition : ์์์ ๋ฐ๋ผ ๊ฒฐ๊ณผ๊ฐ ๋ฌ๋ผ์ง ๋ Mutual exclusion : ํ ํ๋ก์ธ์ค๊ฐ ๊ณต์ ๋ data๋ฅผ accessํ ๋, ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ ๊ฑด๋๋ฆฌ๋ฉด ์๋๋ค๋ ์ฑ์ง Critical section : ๊ณต์ ๋ resource๋ฅผ accessํ๋ ๋ถ๋ถ์ ์ฝ๋ Starvation : Process์๊ฒ ์์์ด ๋ฐฐ์ ๋์ง ์๋ ๊ฒฝ์ฐ Deadlock : Starvation for infinite duration Producer/Consumer : Finite Buffer producer
1item v; 2 3 4while (1) { 5 while (counter == BUFFER_SIZE) ; // busy waiting 6 /* produce item v */ 7 b[in] = v; 8 in = (in + 1) % BUFFER_SIZE; 9 counter++; 10} consumer
1item w; 2while (1) { 3 while (counter == 0) ; // busy waiting 4 w = b[out]; 5 out = (out + 1) % BUFFER_SIZE; 6 counter--; 7 /* consume item w */ 8} => Race condition ๋ฐ์ ๊ฐ๋ฅ
Race Condition in a Uniprocessor counter++, counter–์ ๊ฐ์ ๊ตฌ๋ฌธ์ assembly๋ก ๋ฐ๋๋ฉด 1๊ฐ์ด์์ instruction์ด๋ค. ์ค๊ฐ์ interrupt๊ฐ ๋ฐ์ํ๋ฉด race condition์ด ์๊ธธ ์ ์์ผ๋ฏ๋ก atomicํ๊ฒ ์คํ๋์ด์ผํ๋ค. Race Condition in one Process Multithreading์์๋ race condition์ด ๋ฐ์ํ ์ ์๋ค. Prevent Race Condition (SW solution) ์กฐ๊ฑด Mutual Exclusion : critical section์ ํ๋๊ฐ ์ ๊ทผ ์ค์ด๋ฉด ๋ค๋ฅธ ํ๋๋ ์ ๊ทผ ๋ถ๊ฐ Progress : ์๋ฌด๋ ์์ผ๋ฉด ์ ๊ทผ ๊ฐ๋ฅ Bounded Waiting : ๊ธฐ๋ค๋ฆฌ๋ ๋ฐ ํ๊ณ ์กด์ฌ (P1 -> P3 -> P1 -> P3 .., P2๋?) ๋ฐฉ๋ฒ 1
P0 1do { 2 while (turn != 0) ; 3 /* critical section */ 4 turn = 1; 5 /* remainder section */ 6} while (true); P1 1do { 2 while (turn != 1) ; 3 /* critical section */ 4 turn = 0; 5 /* remainder section */ 6} while (true); P0์์ turn = 1์ ์คํํ๊ธฐ ์ ์ interrupt๊ฐ ๋ฐ์ํ๋ฉด, P1๋ ์ ๊ทผ ๋ถ๊ฐ -> progress ์ฑ์ง ๋ง์กฑ X ๋ฐฉ๋ฒ 2 (Peterson’s Algorithm)
P0 1do { 2 flag[0] = true; 3 turn = 1; 4 while (flag [1] && turn == 1) ; 5 /* critical section */ 6 flag[0] = false; 7 /* remainder section */ 8} while (true); P1 1do { 2 flag[1] = true; 3 turn = 0; 4 while (flag [0] && turn == 0) ; 5 /* critical section */ 6 flag[1] = false; 7 /* remainder section */ 8} while (true); ๋ชจ๋ ์กฐ๊ฑด ๋ง์กฑ ํ๋ก์ธ์ค 2๊ฐ์ผ๋๋ง ์ ์ฉ ๊ฐ์ฌ ๋ฐฉ๋ฒ 3 (Bakery Algorithm)
1do { 2 // number๋ฅผ ๋ถ์ฌ๋ฐ๋ ๊ณผ์ ์ atomic ํ์ง ์๋ค 3 choosing[i] = true 4 // ๊ฐ์ฅ ํฐ ๋ฒํธ + 1์ ๋ถ์ฌ 5 number[i] = max(number[0], number[1], ..., number[n-1])+1; 6 choosing[i] = false; 7 8 for (j=0; j<n; j++) { 9 // ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ choosing ์ค์ธ์ง ์ฒดํฌ 10 while (choosing[i]); 11 12 // ์์ ์ด ๋ฒํธ๋ฅผ ๋ฐ์๋์ง, ๋ฐ๊ธ ๋ฐ์ ๋ฒํธ๊ฐ 1์์์ธ์ง ์ฒดํฌ 13 while ((number[i] != 0) && (number[j], j) < (number[i], i)) ; 14 } 15 16 /* critical section */ 17 18 number[i] = 0 19 20 /* remainder section */ 21 } while (true); ๋ชจ๋ ์กฐ๊ฑด์ ๋ง์กฑ Overhead๊ฐ ๋๋ฌด ํฌ๋ค Test and Set Instruction (HW solution) testset function 1boolean testset (i) { 2 if (i == 0) { 3 // ๋ค์ด๊ฐ์์ค 4 i = 1; 5 return true; 6 } 7 else { 8 // ๋ค์ด๊ฐ์ง ๋ง์์ค 9 return false; 10 } 11} example 1const int n = /* number of processes */; 2int bolt; 3void P(int i) { 4 while (true) { 5 while (! testset(bolt)); 6 /* critical section */ 7 bolt = 0; 8 /* remainder section*/ 9 } 10} 11void main() { 12 bolt = 0; 13 parbegin (P(1), P(2), ... , P(n)) 14} Semaphore (HW solution) ๊ธฐ๋ณธ ์์
1struct semaphore { 2 int count; 3 queueType queue; 4} 5 6void semWait (semaphore s) { 7 s.count --; 8 if (s.count < 0) { 9 // place this process in s.queue; 10 // block this process 11 } 12} 13 14void semSignal (semaphore s) { 15 s.count++; 16 if (s.count <= 0) { 17 // remove a process P from s.queue; 18 // place process P on ready_list 19 } 20} basic example 1const int n = /* number of processes */ 2semaphore s = 1; 3void P (int i) { 4 while (true) { 5 semWait(s); 6 /* critical section */ 7 semSignal(s); 8 /* remainder section */ 9 } 10} 11void main() { 12 parbegin (P(1), P(2), ... , P(n)); 13} producer/consumer example
producer 1semaphore count = 0; 2semaphore empty = BUFFER_SIZE; 3semaphore mut_ex = 1; 4void producer() { 5 while (true) { 6 produce(); 7 semWait(empty); 8 semWait(mut_ex); 9 append(); // put the produced item into buffer 10 semSignal(mut_ex); 11 semSignal(counter); 12 } 13} consumer
1void consumer() { 2 while (true) { 3 semWait(counter): 4 semWait(mut_ex); 5 take(); 6 semSignal(mut_ex); 7 semSignal(empty); 8 consume(); 9 } 10} 11void main() { 12 parbegin (producer1, producer2, ... , consumer); 13} reader/writer example
writer process
1 void writer() { 2 while(true) { 3 semWait(wsem); 4 WRITEUNIT(); 5 semSignal(wsem); 6 } 7 } reader process
1 void reader() { 2 while (true) { 3 semWait(rsem); // ๋ค๋ฅธ reader ์ ๊ทผ ๋ถ๊ฐ 4 readcount++; 5 if (readcount == 1) // ์ฒซ๋ฒ์งธ ๋ค์ด๊ฐ๋ reader 6 semWait(wsem) // writer ์ ๊ทผ ๋ถ๋ฅ 7 semSignal(rsem); // ๋ค๋ฅธ reader ์ ๊ทผ ๊ฐ๋ฅ 8 9 READUNIT(); 10 11 semWait(rsem); // ๋ค๋ฅธ reader ์ ๊ทผ ๋ถ๊ฐ 12 readcount--; 13 if (readcount == 0) // ๋ง์ง๋ง ๋์ค๋ reader 14 semSignal(wsem); // writer ์ ๊ทผ ๊ฐ๋ฅ 15 semSignal(rsem); // ๋ค๋ฅธ reader ์ ๊ทผ ๊ฐ๋ฅ 16 } 17 } binary semaphore semaphore์ ๊ฐ์ด 0๊ณผ 1๋ก ์ ํ ๊ฐ์ด 1๋ก ๋ฐ๋์์ ๋,๋ชจ๋ ํ๋ก์ธ์ค๊ฐ ready state๋ก ๋ณํ Lock
binary semaphore๋ฅผ ์ด์ฉํด ๊ตฌํ๋ ๋๊ธฐํ ๋ฐฉ์ Deadlock Deadlock์ด๋ Starvation : ์ด๋ค ์์์ ๋ค๋ฅธ ํ๋ก์ธ์ค๊ฐ ์ด๋ฏธ ์ ์ ํ๊ณ ์์ด์ ์คํํ ์ ์๋ ์ํฉ Deadlock : 2๊ฐ ์ด์์ process๋ค์ด ์๋ก starvation์ธ ์ํ Deadlock์ ์กฐ๊ฑด์ ํ๋์ฉ ๊นจ๋ณด์ Mutual exclusion : OS์ ํ์ ๊ธฐ๋ฅ Hold and wait : ์์๋ถํฐ ๋ชจ๋ ์์์ ๋ฐ๋๋ก ๊ตฌํ -> ๋นํจ์จ์ No Preemption : ์์์ ์๋ก ๋บ์ด๊ฐ -> ๋นํจ์จ์ Circular Wait : ์์์ ๋จผ์ ๋ฐ์์ผ ํ๋ ๊ฒฝ์ฐ ์กด์ฌ ํด๊ฒฐ๋ฐฉ๋ฒ ์ต์ ์ ๋ฐฉ๋ฒ : deadlock์ด ๋ฐ์ํ์ ๋, ํ ๊ฐ์ฉ ์ฃฝ์ฌ๋ณด๊ธฐ File Management FCB File Control block, ๋ณด์กฐ๊ธฐ์ต์ฅ์น์ ์ ์ฅ ๊ตฌ์ฑ file name, file size, uid, gid, file operation, creation time, last modified, last access time, address of file data…
Device file ๋ธ๋กํ ํ์ผ (๋จ์ : 4096byte) file size ๋์ major number, minor number ์กด์ฌ Device I/O๊ฐ ๋ฐ์ํ๋ฉด ํด๋น Device File๊ณผ I/O ํ๋ฏ์ด ์๋ ๋ฉ์์ง(ํจํท, ํ๋ ์), ๊ณ์ธต OSI 7 Model Physical Data Link Network Transport Session Presentation Application TCP/IP ๊ณ์ธต ๊ณ์ธต ์ด๋ฆ ๋ฉ์์ง ํํ ๋ด์ฉ 1 Phisical Bits Bits 2 Data Link Ethernet Frame Ethernet ์ฃผ์ 3 Network IP packet, Datagram IP ์ฃผ์ 4 Transport TCP Segment, UDP Datagram Port ๋ฒํธ 5 Application HTTP ๋ฉ์์ง, Email ๋ฉ์์ง URL, Email ์ฃผ์ Protocol Suite HTTP - TCP - IP - ARP ์๋ ๋ก๊ทธ ์ ํธ - ์ฌ์ธ ํจ์ $$ y(t) = A sin(2\pi ft + \varphi) $$
A = ํฌ๊ธฐ(amplitude) f = ์ฃผํ์(frequency) $\varphi$ = ์์(phase) ์๋ ๋ก๊ทธ ์ ํธ - ์ฉ์ด ์ฃผ๊ธฐ(Period) : ์ ํธ๊ฐ ๋ฐ๋ณต๋๋ ์๊ฐ ์ฃผํ์ (Frequency) : ์๊ฐ๋น ๋ฐ๋ณต๋๋ ์ ํธ ๊ฐ์ ๋์ญํญ (Bandwidth) : ์๋ ๋ก๊ทธ -> ์ฃผํ์ ๋ฒ์ (Hz), ๋์งํธ -> ๋นํธ ์ ์ก๋ฅ (bps) ๊ด๋ จ ํจ์ 1# start์์ end๊น์ง step ์ฆ๊ฐ 2numpy.arange(start, stop, step) 3# start์์ end๊น์ง step๊ฐ๋ก ๋๋ 4numpy.linspace(start, stop, step) Analog -> Digital PCM (Pulse-code modulation, ํ์ค ๋ถํธ ๋ณ์กฐ) ์๋ ๋ก๊ทธ ์ ํธ์ ๋์งํธ ํํ, ๋์งํธ ๋น๋์ค์ ํ์ค
๊ณผ์ : Sampling(ํ๋ณธํ), Quantization(์์ํ), Encoding(๋ถํธํ) Nyquist sampling theorem ์ ํธ์ ํฌํจ๋ ๊ฐ์ฅ ๋์ ์ง๋์์ 2๋ฐฐ์ ํด๋นํ๋ ๋น๋๋ก ์ผ์ ํ๊ฒ ์ํ๋งํ๋ฉด ์๋์ ์ ํธ๋ก ๋ณต์ํ ์ ์๋ค.
Nyquist bit rate - ๋ฌด์ก์ ์ฑ๋ $$ Bit Rate = 2 \times bandwidth \times log_2(L)$$
bandwidth : ๋์ญํญ L : ์ ํธ ๋ ๋ฒจ Bit rate : ์ด๋น๋นํธ์ ์๋ ์ฉ๋ (Shannon Capacity) - ์ก์์ฑ๋ $$ Capacity = bandwidth \times log_2(1+SNR) $$
SNR์ ์ ํธ์ ๋ํ ์ก์ ๋น์จ Capacity : ์ฑ๋ ์ฉ๋ (bps) SNR์ด ๋ฐ์๋ฒจ(dB)๋ก ์ฃผ์ด์ง๋ ๊ฒฝ์ฐ $$ SNR = 10^{\frac{SNR(dB)}{10}} $$ Digital -> Analog ASK (Amplitude Shift Keying) ๋์งํธ ๋ฐ์ดํฐ๋ฅผ ์ ํธ ํฌ๊ธฐ๋ก ์ ์ก FSK (Frequency Shift Keying) ๋์งํธ ๋ฐ์ดํฐ๋ฅผ ์ฃผํ์๋ก ์ ์ก PSK (Phase Shift Keying) ๋์งํธ ๋ฐ์ดํฐ๋ฅผ ์์์ผ๋ก ์ ์ก QAM (Quadrature Amplitude Modulation) ๋์งํธ ๋ฐ์ดํฐ๋ฅผ ํฌ๊ธฐ์ ๊ฐ๋๋ก ์ ์ก Fourier Transfer ์๊ฐ์ด๋ ๊ณต๊ฐ์ ๋ํ ํจ์๋ฅผ ์ฃผํ์ ์ฑ๋ถ์ผ๋ก ๋ถํดํ๋ ๋ณํ Reed-Solomon(RS) Code n = k(์๋ ๋ฐ์ดํฐ) + n-k(์ค๋ฅ ์ ์ ์ฝ๋) (n-k)/2 = t, t๊ฐ ์ดํ symbol ์ค๋ฅ ์ ์ ๊ฐ๋ฅ Line coding Unipolar NRZ (Non return to Zero) 0 or 1 Polar NRZ-L -1 or 1 Polar NRZ-I -1 or 1, 1์ด ๋์ค๋ฉด transition RZ (Return to Zero) 0 or 5 Manchester ์ ํธ ๋ณํ -> ์ ํธ์ ๋๊ธฐํ Differential Manchester Manchester ๋ฐ๋ Cable ์ ์ก ๋งค์ฒด (Transmission media) Guided(wired) Twisted-pair cable Coaxial cable Fiber-optic cable Unguided(wireless) Radio wave Microwave Infrared Ethernet cable (์ด๋๋ท ์ผ์ด๋ธ) Twisted-pair cable์ ํ ์ข
๋ฅ ์ฌ์ ์ ๊ผฌ์๋๋ ์ด์ : ๋
ธ์ด์ฆ ๋ฐฉ์ง ์ด๋๋ท ์ ์ก ํ๋กํ ์ฝ์ ๋งค์ฒด ์ ๊ทผ ๋ฐฉ์ = CSMA/CD ์ ํ์ , ์ด๋๋ท์ ํ์ฉ Coaxial Cable (๋์ถ ์ผ์ด๋ธ) TV, ์ด๋๋ท์ ํ์ฉ ๋ด๋ถ์ ๋จ์ผ ๊ตฌ๋ฆฌ์ , ์ธ๋ถ ๋์ฒด๋ก ๊ตฌ์ฑ ๊ณ ์ฃผํ์ ์ ํธ๋ฅผ ๋ฉ๋ฆฌ ๋ณด๋ผ ์ ์๋ค Fiber-optic cable (๊ด ์ผ์ด๋ธ) ๋ชจ๋ ๊ตฌ๋ถ Single mode, Multi mode > Step index, Graded index Single mode : ๋น ๋ฅด๊ณ , ๋ฉ๋ฆฌ ๋ณด๋ผ ์ ์๋ค. Multi mode : ์ฌ๋ฌ ๊ฒฝ๋ก๋ก ์ ๋ฌ, ๊ฐ๊ฒฉ์ด ์ธ๊ณ ์ทจ๊ธ์ด ์ฉ์ดํ๋ค ๋ฌด์ ํต์ ๊ธฐ์ ์ ํ : CDMA, LTE, 5G, Bluetooth, Wifi, Zigbee(์ง๋น, ์ ๊ฐ ์ ์ ๋ ฅ ๋คํธ์ํฌ์ ํ์ค) ๋น : Li-fi ์๋ฆฌ : Pied-Piper ๋ค์คํ ๊ธฐ์ Multiplexing ์ 1๊ฐ์ ์ฌ๋ฌ๊ฐ์ง ์ ํธ๋ฅผ ์ ์กํ๋ ๊ธฐ์ ์ก์ ์ -> ์ ํธ -> MUX -> 1 link, n channels -> DEMUX -> ์์ ์ ์ข
๋ฅ FDM, WDM, TDM FDM (์ฃผํ์๋ถํ ๋ค์คํ: Frequency-division multiplexing) ์๋ ๋ก๊ทธ ๊ธฐ์ ์ฌ๋ฌ ๊ฐ์ ์ ํธ๋ฅผ ๊ฐ๊ฐ์ ๋ฐ์ก ์ฃผํ์์ ์ค์ด๋ณด๋ด๋(๋ณ์กฐ) ๊ธฐ์ TDM(์๊ฐ๋ถํ ๋ค์คํ) ๋์งํธ ๊ธฐ์ ์๊ฐ์ ์ ์ก ๋จ๋ง๊ธฐ์ ๋๋์ด ์ฃผ๋๊ฒ ์ ์ก ๋จ์
input slot์ duration output slot์ duration output bit rate output frame rate = ์ด๋น ํ๋ ์ ์ frame duration = 1 / frame rate ํ์ฉ : T1, T3…
T1 ๋ค์คํ 1.544 Mbps๋ก ์์ฑ 24์ฑ๋ (์ ํํ์ )์ ํ๋๋ก ๋ฌถ๋ ๋ค์คํ ์ ์ก Switching ํ์ ๊ตํ๋ง (Circuit-switched Network) ํ์ ์ ์ค์ , ๋ฐ์ดํฐ์ ์ด๋, ํ์ ์ ๋จ์ 3๊ฐ์ง๋ก ์ด๋ฃจ์ด์ง๋ค ๊ณต๊ฐ ๋ถํ ๋ฐฉ์, ์๋ถํ ๋ฐฉ์ ์กด์ฌ ํ์ ์ด ๋จ์ ๋๊ธฐ ์ ๊น์ง๋ ๋
์ ์ด๊ธฐ ๋๋ฌธ์ ์์ ์ ์ด๋ค ์ง์ฐ์๊ฐ์ด ์งง๋ค ํจํท ๊ตํ๋ง (Packet-switched Network) ๊ณ ์ ๋ ๊ฒฝ๋ก๊ฐ ๋ฏธ๋ฆฌ ์ค์ ๋์ง ์๋๋ค ๋ฐ์ดํฐ๊ทธ๋จ ๋ฐฉ์, ๊ฐ์ ํ์ ๋ฐฉ์ ์กด์ฌ
ํจ์จ์ (ํ์ ๋ค์คํ)์ด๊ณ ์ ๋ขฐ๋๊ฐ ๋๋ค(์ฐํ ๊ฐ๋ฅ)
๋๊ธฐ์ง์ฐ์๊ฐ(ํ์) : ๊ตํ๊ธฐ(๋ผ์ฐํฐ)์์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋ ํ ๋ชฉ์ ์ง ์ฃผ์ ๊ฒ์
ํต์ ์์ 4๊ฐ์ง ์ง์ฐ์๊ฐ : ์ ํ์๊ฐ, ์ ์ก์๊ฐ, ํ์์๊ฐ, ์ฒ๋ฆฌ์๊ฐ
ํจํท ๊ตํ๊ธฐ (๋ผ์ฐํฐ) web ๋๋ ssh๋ก ์ ์ ๊ฐ๋ฅ ํจํท ๊ตํ์ ํน์ง ๋ค์คํ: ํจํท์ ์ฌ๋ฌ ๊ฒฝ๋ก๋ก ๊ฒฝ์ ์ฑ๋ : ๊ฐ์ ํ์ ํน์ ๋ฐ์ดํฐ๊ทธ๋จ ๊ตํ ์ฑ๋์ ์ฌ์ฉ ๊ฒฝ๋ก ์ ํ : ํจํท๋ง๋ค ์ต์ ์ ๊ฒฝ๋ก ์ค์ ์์ ์ ์ด : ํจํท์ ์์๋ฅผ ์ ํ๋ค (์์๊ฐ ๋ค๋ฅผ ์ ์๊ธฐ ๋๋ฌธ) ํธ๋ํฝ ์ ์ด : ์ ์ก ์๋ ๋ฐ ํ๋ฆ์ ์ ์ด ์๋ฌ ์ ์ด : ์๋ฌ๋ฅผ ํ์งํ๊ณ ์ฌ์ ์ก ๊ด๋ จ ๋ช
๋ น์ด 1# ๋ผ์ฐํ
ํ
์ด๋ธ, ์ฐ๊ฒฐ๋ ํฌํธ๋ฒํธ ํ์ธ 2netstat -rn 3# ํ์ฑํ๋ ๋คํธ์ํฌ ์ธํฐํ์ด์ค์ ์ธ๋ถ์ฌํญ ํ์ 4ifconfig 5# NATํ
์ด๋ธ์์ vn์ด๋ผ๋ ์ด๋ฆ์ ์ฒด์ธ์ ๋ํ ๊ท์น ์กฐํ 6iptables -t nat -L -vn 7 8# Router view ์๋น์ค๋ฅผ ์ ๊ณตํ๋ ํธ์คํธ์ ์ ์ 9telnet route-views.routeviews.org 10# ํ์ฌ ์ฅ๋น์์ ์ฌ์ฉ๊ฐ๋ฅ ํ ๋ชจ๋ ์ธํฐํ์ด์ค์ ์์ฝ ์ ๋ณด ์ถ๋ ฅ 11show interface summary 12# BGP ํ๋กํ ์ฝ์ ์ฌ์ฉํ๋ ์ฅ๋น์ ์์ฝ ์ ๋ณด ์ถ๋ ฅ 13show ip bgp summary 14# ์ธ๊ตญ ๋ผ์ฐํฐ์์ ์ถฉ๋จ๋๊น์ง ๊ฐ๋ฅํ ๊ธธ 15show ip bgp 168.188.0.0/16 NAT (Network Address Translation : ๋คํธ์ํฌ ์ฃผ์ ๋ณํ) IP ํจํท์์๋ ์ถ๋ฐ์ง ๋ฐ ๋ชฉ์ ์ง์ IP์ฃผ์์ TCP/UDP ํฌํธ ์ซ์ ๋ฑ์ ๋ฐ๊ฟ ์ฌ๊ธฐ๋กํ๋ฉด์ ๋คํธ์ํฌ ํธ๋ํฝ์ ์ฃผ๊ณ ๋ฐ๊ฒํ๋ ๊ธฐ์
BGP (Border Gateway Protocol) ์๋ก ๋ค๋ฅธ ์กฐ์ง์ ๋คํธ์ํฌ๋ฅผ ์ฐ๊ฒฐํ ๋ ์ฌ์ฉํ๋ ๋ผ์ฐํ
ํ๋กํ ์ฝ
ํต์ ์๋ ์ฒ๋ฆฌ์จ (Throughput) A -> B๋ก ์ ์กํ๋ ๋จ์ ์๊ฐ๋น ๋์งํธ ์ ์ก๋ฅ
1# ์๋ฒ networks.cnu.ac.kr:8080 ์ผ๋ก ์ํ ํจํท์ ์ ์ก 2iperf3 -c networks.cnu.ac.kr -p 8080 ๊ฐ์ข
์ ์ก ๋นํธ ์ ์ก๋ฅ ๊ณ์ฐ (๊ฐ์ ์๋ฃ ์ฐธ๊ณ ) ํต์ ์ง์ฐ ์๊ฐ d(nodal) : nodal delay (์ ์ฒด ๋
ธ๋ ์ง์ฐ) d(nodal) = d(proc) + d(queue) + d(trans) + d(prop)
d(proc) : nodal processing delay (๋
ธ๋ ์ฒ๋ฆฌ ์ง์ฐ) ํจํท ํค๋๋ฅผ ์กฐ์ฌํ๊ณ ๊ทธ ํจํท์ ์ด๋๋ก ๋ณด๋ผ์ง ๊ฒฐ์ ํ๋ ์๊ฐ d(queue) : queueing delay (ํ์ ์ง์ฐ) ํจํท์ด ํ์์ ๋งํฌ๋ก ์ ์ก๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ์๊ฐ d(trans) : transmission delay (์ ์ก ์ง์ฐ) ํจํท์ ๋ชจ๋ ๋นํธ๋ฅผ ๋งํฌ๋ก ๋ฐ์ด๋ด๋ ๋ฐ ํ์ํ ์๊ฐ d(prop) : propagation delay (์ ๋ฌ ์ง์ฐ/์ ํ ์ง์ฐ) ๋นํธ๊ฐ ๋ผ์ฐํฐ A ์์์์ ๋งํฌ์์ ๋ผ์ฐํฐ B๊น์ง์ ์ ํ์ ํ์ํ ์๊ฐ ํ
์คํธ ๋ช
๋ น์ด
1ping www.google.com 2traceroute www.eurecom.fr Decibel, dB ์ ํธ ์ธ๊ธฐ์ ์ธก์ ๋จ์ $$ L_b = 10log {B \over A} |dB| $$ ๋ ์ ํธ(A, B) ๊ฐ์ ๋ํ ์๋์ ํฌ๊ธฐ ์ฐจ์ด ์ ๋ ฅ, ๋ฌด์ ์ ํธ ์ ํธ๋ฅผ ๋ฐฉํดํ๋ ์์ ์ฝํ (attenuation) ์๊ณก (distortion) ์ก์ (noise) (SNR:Signal-to-noise ratio : ์ ํธ ๋ ์ก์ ๋น์จ) ์งํฐ ์ง์ฐ๊ฐ์ด ๋ค์ํ๊ฒ ๋ฌ๋ผ์ง๋ ๊ฒ (๋ค์ญ๋ ์ญ)
๋ฐ์ดํฐ ๋งํฌ ๊ณ์ธต ๋ฐ์ดํฐ ๋งํฌ ๊ณ์ธต ๋ฌผ๋ฆฌ ๊ณ์ธต์ ์ด์ฉํ์ฌ ์ ์ก ์ฅ๋น : ๋ธ๋ฆฌ์ง, L2 switch(ethernet address) ์๋ธ ๊ณ์ธต 2๊ฐ ๋
ผ๋ฆฌ์ ๋งํฌ ์ ์ด ๋งค์ฒด ์ ๊ทผ ์ ์ด Mac Address Network interface card(NIC) identifier ๋๋ถ๋ถ ๊ณ ์ , ์ผ๋ถ๋ ๊ฐ๋ณ 48๋นํธ 6๋ฐ์ดํธ (MAC-48) IP Address IPv4 : 32bit (4bytes) IPv6 : 128bit (16bytes) Class ๊ตฌ๋ถ ์์(2์ง์) ์์ (10์ง์) ๊ตฌ์ฑ host ๋ฒ์ A 0 1~126 network 7, host 24 $2^7-1$ B 10 128.0~191.255 network 14, host 16 $2^{14}$ C 110 192.0.0~223.255.255 network 21, host 8 $2^ {22}$ ์) 192.168.1.132, subnet mask = 255.255.255.192 ํด๋น ์ฃผ์ 192.168.1.128 (132 & 192)
๋คํธ์ํฌ ์ฃผ์์, ๋ธ๋ก๋์บ์คํธ ์ ์ธํ ํธ์คํธ ๊ฐ์ $2^6-2 = 62๊ฐ$
CIDR (Classless Inter-Domain Routing) ์) 143.7.65.203/24 ์ฃผ์ ๊ณต๊ฐ ์์์ 24๋นํธ ๋นผ๊ณ ์ฌ์ฉ ๊ฐ๋ฅ : 143.7.65.0 ~ 143.7.65.255
์๋ธ๋ท ๋ง์คํฌ ์ 24์๋ฆฌ๊ฐ 1์ด๋ค : 255.255.255.0
๋ธ๋ก๋์บ์คํธ์ฃผ์ ์ฃผ์๊ณต๊ฐ์ ๋ง์ง๋ง ์ฃผ์ : 143.7.65.255
ARP, PPP ARP (Address Resolution Protocol) IP ์ฃผ์ (๋ธ๋ก๋์บ์คํธ ์ฃผ์) -> MAC ์ฃผ์ ๋ณํํด์ฃผ๋ L2 ํ๋กํ ์ฝ
Reverse ARP : MAC ์ฃผ์ -> IP ์ฃผ์
Gratuitous ARP : ์์ ์ IP ์ฃผ์๋ฅผ ์๋ฆฌ๊ธฐ ์ํด ์ฌ์ฉ
ARP ํ
์ด๋ธ
IP ์ฃผ์, MAC ์ฃผ์, TTL(Time To Live) TTL : ARP ํ
์ด๋ธ์ ์๋ ์ฃผ์์ ์ ํจ๊ธฐ๊ฐ ARP ํ
์ด๋ธ์ ์๋ ๊ฒฝ์ฐ, ARP Request๋ฅผ ๋ณด๋ธ๋ค Proxy ARP : ๋ค๋ฅธ ๋คํธ์ํฌ์ ํธ์คํธ์ IP ์ฃผ์๋ฅผ ์๋ ค์ฃผ๋ ๋ผ์ฐํฐ (์ฃผ๋ก ๊ณต์ ๊ธฐ) ARP Spoofing : ARP ํ
์ด๋ธ์ ์์กฐํ์ฌ ๊ณต๊ฒฉํ๋ ๊ธฐ๋ฒ PPP (Point-to-Point Protocol) ์ปดํจํฐ/๋ผ์ฐํฐ ๊ฐ ์ง์ ์ฐ๊ฒฐํ๋ ๊ฒฝ์ฐ ํ์ํ L2 ํ๋กํ ์ฝ
PPP ๊ธฐ๋ฅ : ์ธ์ฆ, ์ ์ก, ์ํธํ, ๋ฐ์ดํฐ ์์ถ
์ธ๋ถ ํ๋กํ ์ฝ : LCP, NCP
NCP (Network Control Protocol)
IP, IPX, AppleTalk ๋ฑ์ ํ๋กํ ์ฝ์ ์ํ ํ๋กํ ์ฝ PPP ํ๋ ์์ ํ๋กํ ์ฝ ํ๋์ ์ฌ์ฉ๋จ PPTP (Point-to-Point Tunneling Protocol) PPP๋ฅผ ์ด์ฉํ VPN (Virtual Private Network) ๊ตฌํ ํ๋กํ ์ฝ Tunneling packets : ํจํท ์์ ํจํท์ ๋ฃ์ด์ ์ ์กํ๋ ๋ฐฉ๋ฒ ๊ณต์ ๊ธฐ์ ๊ธฐ๋ฅ ์ค ํ๋ NAT, ๊ณต์ ๊ธฐ ๊ณต์ ๊ธฐ (Network Address Translator) IP ์ฃผ์ ๋ณํ : public IP <-> private IP
NAT๊ฐ ์ฌ์ฉํ๋ ์ฌ์ค IP ์ฃผ์
RFC1918 name CIDR Host size Mask bits Classful description 24-bit block 10.0.0.0/8 24 bits 8 bits single class A network 20-bit block 172.16.0.0/12 20 bits 12 bits 16 contiguous class B networks 16-bit block 192.168.0.0/16 16 bits 16 bits 256 contiguous class C networks ์ฃผ์๋ฒ์ญ
IP์ฃผ์, Port๋ฒํธ ๋๋ค ๋ณํ๋ค NAT์ ์ฌ์ฉ : IP ๊ณต์ ๊ธฐ, ํ
๋๋ง, Docker, VirtualBox, ์ด๋ํต์ ๋ง, Cloud
๊ณต์ ๊ธฐ = ํ๋กํ ์ฝ์ ์งํฉ DNS Server (L7) IP Router + NAT + DHCP (L3) Bridge, Ethernet Switch, Ethernet, Wifi (L2) Modem (L1) ๋นํธ์ค๋ฅ ํ์ง ๋ฐ ์์ ์ฉ์ด ๋ฐ์ดํฐ ์๋ : ์๋ ๋ฐ์ดํฐ k bits ์ฝ๋์๋ : ๋ฐ์ดํฐ ์๋ + r bits์ ์ค๋ฅํ์ง ์ฝ๋ ๋น์ ๋ขฐ์ฑ ์ฑ๋ (์ค๋ฅ๊ฐ ๋ฐ์ ๊ฐ๋ฅ) ์ด๋ผ๊ณ ๊ฐ์ ํด๋ฐ ๊ฑฐ๋ฆฌ (Hamming distance) : ๋ ์ฝ๋์๋์ ๋นํธ๊ฐ ๋ค๋ฅธ ๊ฐ์ ์ต์ ํด๋ฐ ๊ฑฐ๋ฆฌ : ์ฝ๋์๋ ๊ฐ์ ์ต์ ํด๋ฐ ๊ฑฐ๋ฆฌ ์ฝ๋์๋ ๋นํธ ์๋ฌ ํ์ง s๊ฐ์ ์ค๋ฅ๋ฅผ ํ์งํ ์ ์๋ค. $$ d_{min} = s + 1$$ t๊ฐ์ ์ค๋ฅ๋ฅผ ์์ ํ ์ ์๋ค. $$ d_{min} = 2t + 1$$ ์ค๋ฅ๋ฅผ ํ์งํ๋ ๋ฐฉ๋ฒ Parity bit Even or Odd, ์ค๋ฅ ํ์ง ๋ฅ๋ ฅ CRC (Cyclic Redundancy Check) ๋ฐ์ดํฐ ์๋๋ฅผ x๋ก ๋๋ ๋๋จธ์ง๋ฅผ ์ฝ๋์๋์ ์ถ๊ฐ Checksum ๋ฐ์ดํฐ ์๋์ ๋ชจ๋ ๋นํธ๋ฅผ ๋ํ ๊ฐ์ ๋ณด์๋ฅผ ์ฝ๋์๋์ ์ถ๊ฐ ์ฐ์ด๋ ๊ณณ : IPํค๋, UDP ํค๋, TCPํค๋ ์ค๋ฅ๋ฅผ ํ์ง ๋น ๋ณต๊ตฌํ๋ ๋ฐฉ๋ฒ FEC Reed Solomon Code (n-k)/2 = t๊ฐ ์ดํ symbol ์ค๋ฅ ์ ์ ๊ฐ๋ฅ (k๋ ๋ฐ์ดํฐ์๋ ๊ธธ์ด, n์ ์ฝ๋ ์๋ ๊ธธ์ด) ์ค๋ฅ์ ์ด : ์ฌ์ ์ก Stop-and-Wait ARQ ์ ์ก ํ, ACK๋ฅผ ๋ฐ์์ผ ๋ค์ ํจํท์ ์ ์ก Go-Back-N ARQ N๊ฐ์ ํจํท์ ์ ์กํ๊ณ , ACK๋ฅผ ๋ฐ์ผ๋ฉด ๋ค์ N๊ฐ๋ฅผ ์ ์ก ํจํท 1,2,3,4,5 ์ค 3์ด ๋ถ์ค๋๋ฉด 4,5์ ๋ํ ACK๋ 2 -> ์์๊ฐ ํ๋ฆฌ๋ฉด ๋ค์ ๊ฒ์ ๋ค ๋ฒ๋ฆฐ๋ค -> ๋นํจ์จ์ ๋ฌธ์ ๊ฐ ์๊ธฐ๋ ๊ฒฝ์ฐ : ACK๊ฐ ๋ชจ๋ ๋ถ์ค๋๋ ๊ฒฝ์ฐ Selective Repeat ARQ ํจํท 1,2,3,4,5 ์ค 3์ด ๋ถ์ค๋๋ฉด 4,5์ ๋ํ ACK๋ ๊ฐ๊ฐ 4, 5 -> ์์๊ฐ ํ๋ ค๋ ๋ค์ ๊ฒ์ ๋ฒํผ์ ์ ์ฅ ๋ฌธ์ ๊ฐ ์๊ธฐ๋ ๊ฒฝ์ฐ : ACK๊ฐ ๋ชจ๋ ๋ถ์ค๋๋ ๊ฒฝ์ฐ ์๋์ฐ ํฌ๊ธฐ ARQ ์ก์ ์ ์๋์ฐ ํฌ๊ธฐ ์์ ์ SW 0 or 1 1 GN $2^m-1$ 1 SR $2^{m-1}$ $2^{m-1}$ RTT (Round Trip Time) $$ U_{sender} = {L/R \over RTT+L/R} $$
์ด๋๋ท๊ณผ ๋ ์ด๋๋ท ์ต์ํฌ๊ธฐ : 64bytes ๋นํธ ์ ํ ์๋ : 2.8$\mu$s ์ ์ก ์ง์ฐ์๊ฐ : 64byte / 10Mbps = 51.2$\mu$s ์ต๋ ๊ฑฐ๋ฆฌ : 2*10^8m/s * 51.2/2 = 5.12km 2500m ์ด๋ด์ ์ถฉ๋์ ๊ฐ์งํ๊ธฐ์ํด์ 64byte๋ก ์ค๊ณ (2๋ฐฐ ๋ฒํผ) Mac์ฃผ์ 6byte (48bit) ํ์ค ์ด๋๋ท MAC IEEE 802.3 (CSMA/CD) 1-persistent : ์ ํธ ๊ฐ์ง ํ๋กํ ์ฝ ์ ํ์ง์ฐ = ์ ์ก๊ฑฐ๋ฆฌ / ์ ํ์๋ ์ ์ก์ง์ฐ = ํจํทํฌ๊ธฐ / ๋์ญํญ a = ์ ํ์ง์ฐ / ์ ์ก์ง์ฐ Efficiency $$ 1 \over (1 + 6.4 \times a) $$ ํ๋ ์ด๋๋ท ์ค์์น, ์ด๋๋ท : ์ถฉ๋X, CSMA/CD -> CSMA/CA ๊ฐ์ ๋ ์๋ฌ์ ์ด : GE : FEC, 10GE : ITU G.975 Reed Solomon Code, ์ฌ์ ์กX Virtual LAN (VLAN) ๋ฌผ๋ฆฌ์ ์ผ๋ก ๋จ์ด์ง LAN์ ๊ฐ์ LAN์ผ๋ก ๊ตฌ์ฑํ๋ ๊ธฐ์ VirtualBox, Docker์์ ํ์ฉ LAN์์์ ์ฌ์ดํด ๋ฌธ์ ์ด๋๋ท์ TTLํ๋๊ฐ ์์ -> ๋ฃจํ ๋ฐ์์ ํธ๋ํฝ์ด ํญ์ฃผ Spanning Tree Protocol (STP) ์ฌ์ฉ MAC - CSMA/CD (IEEE 802.3) ๋งค์ฒด์ ๊ทผ์ ์ด ๊ธฐ์ ์ฌ๋ฌ ์ก์ ์ - ์ฌ๋ฌ ์์ ์์์ ๊ณต์ ๋งค์ฒด๋ฅผ ์ฌ์ฉํ ๋, ์ถฉ๋์ ๋ฐฉ์งํ๊ธฐ ์ํ ๊ธฐ์ Aloha ๊ทธ๋ฅ ๋ณด๋ธ๋ค -> ์ถฉ๋์ด ๋ฐ์ํ๋ฉด ์ฌ์ ์ก Slotter aloha : ์ฌ๋กฏ์ ๋๋ ์ ๋ณด๋ธ๋ค ์ดํ์ ์ด๋๋ท์ผ๋ก ๋ฐ์ ํ๋๋ฐ ๊ธฐ์ฌ G = ํ๋ ์ 1๊ฐ ์ ์กํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ (ms) slotted aloha์ ์ฒ๋ฆฌ์จ $$ S = G \times e^{-G} $$ aloha์ ์ฒ๋ฆฌ์จ $$ S = G \times e^{-2G} $$ CSMA/CD (Carrier Sense Multiple Access with Collision Detection) ์ ์ก ํ๋ ์ ์ค๋น ๋งค์ฒด ์ฌ์ฉ์ด ๊ฐ๋ฅํ ๋๊น์ง ๋๊ธฐ (carrier sensing) ์ ์ก ์์ (multiple access) ์ถฉ๋์ด ์ผ์ด๋ฌ๋ค๋ฉด ์ถฉ๋ ํ์ง ์ ์ฐจ๋ก ์ด๋ (collision detection ์ฌ์ ์ก ์นด์ดํฐ๋ฅผ ์ด๊ธฐํํ๊ณ ํ๋ ์ ์ ์ก ์ข
๋ฃ ์ถฉ๋ ๋ฐ์ ์ ์ผ ์ ํธ๋ฅผ ๋ชจ๋์๊ฒ ์ ๋ฌ๋๋๋ก ์ต์ ํจํท ์ ์ก ์๊ฐ๊น์ง ๊ณ์ ์ ์ก ์ฌ์ ์ก ์นด์ดํฐ๋ฅผ ์ฆ๊ฐ์ํจ๋ค ์์์ ์๊ฐ ๋์ ๋๊ธฐ (backoff) (์ถฉ๋ํ ๋๋ง๋ค 2๋ฐฐ์ฉ ์ฆ๊ฐ) ํ๋์ Ethernet ์ค์์น(์ ํธ๊ฐ ์ง๋๋ ๊ธธ์ ๋๋๋ค) ํ๊ฒฝ : ์ถฉ๋X Full Duplex CSMA/CD ์ฌ์ฉ X Carrier Sensing Nonpersistent : ๋งค์ฒด๊ฐ ์ฌ์ฉ์ค์ด๋ฉด, ์์์ ์๊ฐ ํ ๋ค์ ์ผ์ฑ, ์ฌ์ฉ์ค์ด์ง ์์ผ๋ฉด ๋ฐ๋ก ์ ์ก Persistent : ์ผ์ฑ์ ์ง์์ ์ผ๋ก, ๋๊ณ ์์ด๋ ๋ฐ๋ก ์ ์กํ์ง ์๋๋ค p-persistent : pํ๋ฅ ๋ก ๋ณด๋ด๊ธฐ (1-persistent : ๋ฐ๋ก ๋ณด๋ด๊ธฐ) CSMA/CA CSMA/CD -> ๋ฌด์ ์์๋ ์ ์ฉํ๊ธฐ ์ด๋ ต๋ค ๋์ ์ก์์ ์ ๋ง์ ์๋์ง๋ฅผ ์๋ชจ Hidden station problem ๋ฐ์ ๊ฐ๋ฅ (๋ฌด์ ์์๋ง ๋ฐ์) ์ ํธ ๊ฐ์ -> ์ถฉ๋ ๊ฐ์ง๊ฐ ์ด๋ ค์ CSMA/CA (Carrier Sense Multiple Access with Collision Avoidance) Idle ์ํ์์ IFS(Inter Frame Space)๋งํผ ๋๊ธฐ IFS ๊ธฐ๋ค๋ฆฐ ๋ค์๋ idle ์ํ๋ผ๋ฉด Contention Window ๋ด slot time๋งํผ ๋๊ธฐ RTS/CTS ๋์
(ํ์ฌ ๋ฉ์์ง๋ฅผ ๋ณด๋ด๋ ๋๋์ง ํ์ธ) -> Hidden station problem ํด๊ฒฐ NAV (Network Allocation Vector) ๋งค์ฒด๋ฅผ ์ผ๋ง๋ ์ฌ์ฉํ ์ง๋ฅผ ์๋ ค์ฃผ๋ ๊ฐ -> ์ถฉ๋ํํผ๋ฅผ ๋๋๋ค
Exposed Station Problem ๋ค๋ฅธ ๋
ธ๋ ์์ ์ ์ก์ผ๋ก ์ธํด ์ ์ก์ ํ์ง ๋ชปํ๋ ์ํฉ
Wifi Wifi IEEE 802.11 ํ์ค์ ๊ทผ๊ฑฐํ Wireless LAN
AlohaNet -> Ethernet -> Wifi
๊ตฌ์ฑ๋ฐฉ๋ฒ
AP (Access Point) ์ด์ฉ Ad-hoc (Peer-to-Peer) ๋ฐฉ์ ์ธ์ฆ ๋ฐฉ์ : WPA, WPA2, EAP
MAC ๊ธฐ์ : CSMA/CA, RTS/CTS, NAV
ํ๋ ์ : IEEE 802.11
IEEE 802.11 ํ๋ ์ FC D Addr1 Addr2 Addr3 SC Addr4 Frame body CRC FC (Frame Control)
Protocol version Type Subtype To DS From DS More frag Retry Pwr mgt More Data WEP Rsvd Subtype : 1011 (RTS), 1100 (CTS), 1101 (ACK)
AP๊ฐ ๊ฐ์
๋๋ ํ๊ฒฝ ๋ฑ ์ฌ๋ฌ ์ํฉ์ ๊ณ ๋ ค -> ์ฃผ์ ํ๋๊ฐ 4๊ฐ
Wifi ์์ฉ ๊ธฐ์ MIMO (Multiple Input Multiple Output) : ์ํ
๋ ๊ฐ์ ์ฆ๊ฐ -> ์ฑ๋ฅ ์ฆ๊ฐ ์ ํ๋ง, ์ผ์ด๋ธ๋ง, ๊ดํ
์ํฌ ์ ํ๋ง SS7(Signaling System 7) ์ ํ๋ง์ ์ ์ด๋ฅผ ์ํ ํ๋กํ ์ฝ
DSL ์ ํ๋งํฌ ์ด์ฉํ ๊ณ ์ ํต์ ๊ธฐ์
์ผ์ด๋ธ๋ง HFC ๊ด์ผ์ด๋ธ + ๋์ถ์ผ์ด๋ธ
๊ด๋คํธ์ํฌ SONET (Synchronous Optical Network)
๊ด์ผ์ด๋ธ์ ์ด์ฉํ ๋คํธ์ํฌ
ATM (Asynchronous Transfer Mode)
๊ฐ์ํ์ ์ด์ฉ ๋น๋๊ธฐ ํต์ ๊ธฐ์ : ํ์ + ํจํท ๊ตํ๋ง ๊ธฐ์
ํจํท(์
) : ๊ณ ์ 53Byte
์ด๋ํต์ ๋ธ๋ฃจํฌ์ค 2.4Ghz ๋ฌด์ ์ฑ๋ ์ฌ์ฉ FHSS RTLS (Real Time Location System) : ์ค์๊ฐ ์์น ์ถ์ ์์คํ
Zigbee ์ํ, ์ ์ ๋ ฅ ๋ฌด์ ๋คํธ์ํฌ๋ฅผ ์ํ ๊ธฐ์ ์ด๋ํต์ ๋ง ์ฝ์ด๋คํธ์ํฌ + ์ก์ธ์ค ๋คํธ์ํฌ 3G ๋คํธ์ํฌ GGSN (Gateway GPRS Support Node) GPRS ๋คํธ์ํฌ์ ์ธ๋ถ ๋คํธ์ํฌ๋ฅผ ์ฐ๊ฒฐํ๋ ๋ผ์ฐํฐ 06-File-Management Directory File Directory Directory๋ ์ผ์ข
์ ํ์ผ์ด๋ค ํด๋น ํ์ผ FCB์ ์๋ณ์๋ง ์ ์ฅํ๋ค inode (index node) Unix์์๋ FCB์ inode๊ฐ ๊ฐ๋ค ๋ชจ๋ ํ์ผ, ํด๋๊ฐ Uniqueํ ๊ฐ์ ๊ฐ์ง๋ค. (root๋ 2๋ก ๊ณ ์ ) File Systems ํํฐ์
์ ๊ตฌ์กฐ boot block, super block, FCB list, data blocks Partition Control block (Super block) blocks ๊ฐ์, free data blocks ๊ฐ์, free data blocks list ์ ์ฅ inode table, free inode ๊ฐ์, free inode list ์ ์ฅ File Control Block (FCB) UNIX์์ 128byte์ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ค ํ์ผ ์ด๋ฆ, ํ์ผ ํฌ๊ธฐ, uid, gid, ํ์ผ ์ฃผ์ ๋ฑ๋ฑ ์ ์ฅ Management of Data Blocks Contiguous Allocation ๊ฐ๊ฐ์ ํ์ผ์ ์ฐ์์ ์ผ๋ก ์ ์ฅ Direct Access File grow problem ์กด์ฌ External fragmentation, Internal fragmentation ๋ฐ์ Chained Allocation Direct acess File grow problem X External fragmentation X Poor data safety (์ ๋ธ๋ก์ ๋ฌธ์ ๊ฐ ์๊ธฐ๋ฉด ๋ค ๋ธ๋ก๋ ์ฌ์ฉ ๋ถ๊ฐ๋ฅ) Indexed Allocation (ํ๋์ ์ฌ์ฉ) Direct access File grow problem X External fragmentation X Medium level data safety (index block๋ง ๊ด์ฐฎ์ผ๋ฉด ๋๋ค) Index block์ด ์ถ๊ฐ๋ก ํ์ํ๋ค Free-Space Management Counting N-M… N๋ฒ๋ถํฐ M๊ฐ์ ๋ธ๋ก์ด ๋น์ด์๋ค. Linked List ๋น์ด์๋ ๋ธ๋ก๋ค์ ์ฐ๊ฒฐ๋ฆฌ์คํธ๋ก ๊ด๋ฆฌํ๋ค. Grouping ๋น์ด์๋ ๋ธ๋ก๋ค์ ๊ทธ๋ฃน์ผ๋ก ๊ด๋ฆฌํ๋ค. Bit Vector ๋ชจ๋ ๋ธ๋ก๋ค์ ๋นํธ๋ก ๊ด๋ฆฌํ๋ค. (0์ด๋ฉด ์ฌ์ฉ ์ค, 1์ด๋ฉด ๋น์ด์์) ๋จ์ : ์ฉ๋์ ๋ง์ด ์ฐจ์งํ๋ค. File System Example (UNIX) Addresses of Data Blocks Index ๋ธ๋ก ํ๋๋ 4096 byte 4096 / 4 = 1024๊ฐ์ ๋ธ๋ก ์ฃผ์๋ฅผ ์ ์ฅํ ์ ์๋ค. 10๊ฐ์ data blocks๋ inode๋ด(direct block field)์ ์ ์ฅํ๋ค Data Block Addressing direct block 10๊ฐ : 40KB (10 X 4 X 2^10 bytes) single indirect block 1๊ฐ : 4MB (4KB X 2^10 = 2^22 bytes) double indirect block 1๊ฐ : 4GB (4KB X 2^10 X 2^10 = 2^32 bytes) triple indirect block 1๊ฐ : 4TB File System Example (Linux) Virtual File System ์ ์ฉ Linux Inode Inode์ ํฌ๊ธฐ : 128 bytes (ext2, ext3), 256 bytes (ext4) Direct block 12๊ฐ, Indirect block 3๊ฐ 07-IO-Management-Disk-Scheduling Kernel Modules for IO Management Kernel I/O Management Device Scheduling Error handling Buffering (copy semantics๋ฅผ ์ ์ง) Caching : ๋น ๋ฅธ ์๋๋ฅผ ์ํด ์ฌ์ฉ Spooling : ๋ณด์กฐ ๊ธฐ์ต ์ฅ์น์ ์์๋ก ์ ์ฅ (์ฌ๋ฌ ์ฌ๋์ด ๊ณต์ ํ๊ธฐ ๋๋ฌธ) Interrupt handling Interrupt ์ฃผ๋ณ ์ฅ์น -> OS : ๋น๋๊ธฐ์ ์ด๋ฒคํธ์ ๋ฐ์์ ์๋ฆผ IDT (Interrupt Descriptor Table = IVT) : ์ธํฐ๋ฝํธ ๋ฒํธ์ ISR์ ์ฃผ์๋ฅผ ์ ์ฅ ISR (Interrupt Service Routine) : ์ธํฐ๋ฝํธ ๋ฐ์ ์ ์คํ๋๋ ํจ์ Interrupt ์ฒ๋ฆฌ ๊ณผ์ Mode change IDT์์ ISR์ ์ฃผ์๋ฅผ ์ฐพ์์ ์คํ ISR์์ ๊ธํ ์ผ ๋ถํฐ ์ฒ๋ฆฌ, ํ์ํ๋ฉด ๋ฏธ๋ฃฌ๋ค Scheduler๊ฐ ํ ์ผ์ ๊ฒฐ์ Trap OS์๊ฒ ๋๊ธฐ์ ์ด๋ฒคํธ์ ๋ฐ์์ ์๋ฆผ ์) div_by_zero, seg_fault, protection_fault, page_fault page fault๋ง ํ๋ก์ธ์ค๋ฅผ ์ข
๋ฃ ์ํค์ง ์์ Kernel์ Interrupt์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์ฒ๋ฆฌ System Call Process -> OS : ๋๊ธฐ์ ์ด๋ฒคํธ์ ๋ฐ์์ ์๋ฆผ System call ์ฒ๋ฆฌ Using system call table ex) int $0x80 sysenter ๋ช
๋ น I/O Control : Polling I/O Control Polling : ์ฃผ๊ธฐ์ ์ผ๋ก I/O ์ฅ์น์ ์ํ๋ฅผ ํ์ธ Interrupt-driven I/O : I/O ์ฅ์น๊ฐ ์ธํฐ๋ฝํธ ๋ฐ์ DMA(Direct Memory Access) : CPU์ ๊ฐ์
์์ด ๋ฉ๋ชจ๋ฆฌ์ ์ฃผ๋ณ์ฅ์น ์ฌ์ด์ ๋ฐ์ดํฐ ์ ์ก Polling Busy-wait cycle Host๊ฐ busy bit๋ฅผ ๋ฐ๋ณต์ ์ผ๋ก ํ์ธ Host๊ฐ write bit ์ค์ , data-out register์ ๋ฐ์ดํฐ ์ ์ฅ Host๊ฐ command-ready bit ์ค์ Controller๊ฐ command-ready bit ์ค์ ์ ํ์ธํ๋ฉด busy bit ์ค์ Controller๊ฐ control register (write command)๋ฅผ ์ฝ๊ณ , data-out register์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๋๋ค I/O๊ฐ ๋๋๋ฉด controller๊ฐ command-ready bit, busy bit ํด์ ํน์ง I/O๊ฐ ๋นจ๋ฆฌ ๋๋๋ฉด ํจ์จ์ , ๋ฆ๊ฒ ๋๋๋ฉด ๋นํจ์จ์ I/O Control : Interrupt I/O, DMA Interrupt-Driven I/O 1~3์ Polling๊ณผ ๋์ผ 4 : Process management๋ฅผ ํตํด Context switch 8 : IO๊ฐ ๋๋๋ฉด Interrupt ReQuest(IRQ)๋ฅผ cpu์๊ฒ ๋ณด๋ธ๋ค ์ฅ์ : ์ฃผ์ด์ง ์๊ฐ์์ ๋ง์ ํ๋ก์ธ์ค ์์ฉ ๊ฐ๋ฅ, I/O๊ฐ ๋๋ฆด์๋ก ํจ์จ์ ๋จ์ : I/O๊ฐ ๋น ๋ฅด๋ฉด ๋นํจ์จ์ (์ฆ์ Context Switch, mode change) DMA (Direct Memory Access) ๊ธฐ์กด ๋ฐฉ์์ ๋ฌด์กฐ๊ฑด processor๋ฅผ ๊ฑฐ์ณ๊ฐ์ผํ๋ค DMA ๋ชจ๋์ด I/O์ Memory ์ฌ์ด ์ญํ ์ํ, ๋๋๋ฉด Interrupt ๋ฐ์ ์ฅ์ : CPU๊ฐ ๋ค๋ฅธ ์์
๊ฐ๋ฅ, ๋น ๋ฅด๋ค Disk Scheduling Disk Structure Sector, Track, Cylinder Disk๋ logical block์ ๋ฐฐ์ด์ด๋ค Timing of a Disk I/O Transfer Seek time : ์ฑ๋ฅ์ ํฐ ์ํฅ์ ๋ฏธ์น๋ค Rotational delay Transfer time Disk Scheduling Policies FIFO ์์ฒญ ์์๋๋ก ์ฒ๋ฆฌ SSTF (Shortest Seek Time First) ํ์ฌ ์์น์์ ๊ฐ์ฅ ๊ฐ๊น์ด ์์ฒญ์ ์ฒ๋ฆฌ starvation ๋ฌธ์ ๋ฐ์ (์๋ฅผ ๋ค์ด ์์ ์ซ์๋ง ๋์ค๋ฉด?) SCAN (Elevator Algorithm) ํ ๋ฐฉํฅ์ผ๋ก ํ์ผ๋ฉด์ ์ฒ๋ฆฌ ์ฑ๋ฅ ๋น๊ต SSTF > SCAN > FIFO Disk Cache Main memory์ ๋ช๋ช ์นํฐ์ ๋ณต์ฌ๋ณธ์ ์ ์ฅ Replacement Policy LRU (Least Recently Used) ๊ฐ์ฅ ์ค๋ซ๋์ ์ฌ์ฉํ์ง ์์ ์นํฐ๋ฅผ ๊ต์ฒด LFU (Least Frequently Used) ๊ฐ์ฅ ์ ๊ฒ ์ฌ์ฉ๋ ์นํฐ๋ฅผ ๊ต์ฒด RAID RAID Redundant Array of Inexpensive Disks : ์ ๋ ดํ ์ฌ๋ฌ ๊ฐ์ ๋์คํฌ ๋ฌถ์
RAID 0 (non-redundant) ๋ฐ์ดํฐ๋ฅผ ์ฌ๋ฌ ๋์คํฌ์ ๋ถ์ฐ ์ ์ฅ ์ฅ์ : ์ฉ๋์ด 4๋ฐฐ ๋จ์ : ํ๋์ ๋์คํฌ๊ฐ ๊ณ ์ฅ๋๋ฉด ๋ชจ๋ ๋ฐ์ดํฐ ์์ค RAID 1 (mirrored) RAID 0์ ๋ณต์ ์ฅ์ : ์ ๋ขฐ์ฑ์ด ๋๋ค ๋จ์ : ๋์คํฌ๊ฐ 2๋ฐฐ๋ก ๋ค์ด๊ฐ๋ค RAID 3 (bit-interleaved parity) ํ ๋์คํฌ์ parity bit๋ฅผ ์ ์ฅ (๊ฐ์ ์์น์ bit๋ค์ parity) ์ฅ์ : ํ๋์ ๋์คํฌ ๋ณต์ ๊ฐ๋ฅ ๋จ์ : ์ด๋ค ๋์คํฌ๊ฐ ๊ณ ์ฅ๋ฌ๋์ง ์ ์ ์๋ค, 5๊ฐ๋ฅผ ๋์์ ์ฝ์ด์ ๋๋ฆผ RAID 4 (block-level parity) ํ ๋์คํฌ์ parity bit๋ฅผ ์ ์ฅ (๊ฐ์ ์์น์ block๋ค์ parity) ์ฅ์ : ๋ธ๋ก ๋จ์ -> ๋ณ๋ ฌ์ ์ผ๋ก IO ๊ฐ๋ฅ (RAID 3๋ณด๋ค ๋น ๋ฆ) ๋จ์ : ์ด๋ค ๋์คํฌ๊ฐ ๊ณ ์ฅ๋ฌ๋์ง ์ ์ ์๋ค RAID 5 (block-level distributed parity) RAID 4์ ๋์ผํ๋ parity bit๋ฅผ ์ฌ๋ฌ ๋์คํฌ์ ๋ถ์ฐ ์ ์ฅ RAID 6 (dual redundancy) RAID 5์ ๋์ผํ๋ parity bit๋ฅผ 2๊ฐ ์ ์ฅ (1๊ฐ๋ odd, 1๊ฐ๋ even) ์ฅ์ : RAID5 ๋ณด๋ค ๋์ ์ ๋ขฐ์ฑ RAID 01, RAID 10 RAID 0๊ณผ RAID 1์ ํฉ์น ๊ฒ RAID 01 < RAID 10 08-Memory-Management Memory Management Memory Management Requirements Memory Allocation : ํ๋ก์ธ์ค๋ณ๋ก ๋ฉ๋ชจ๋ฆฌ ํ ๋น Memory Protection : ๊ฐ ํ๋ก์ธ์ค๊ฐ ํ์ฉ๋ ์์ญ๋ง ์ ๊ทผ ๊ฐ๋ฅ Relocation : ํฉ์ด์ง ์์ ๊ณต๊ฐ์ ํฉ์น๊ธฐ Sharing : ๋ถ๋ชจ ์์ ํ๋ก์ธ์ค ๊ฐ shared memory Memory Partitioning Fixed Partitioning : ๊ฐ์ ํฌ๊ธฐ์ ๊ณต๊ฐ์ผ๋ก ๋๋ ์ ํ ๋น
์ฅ์ : ๊ฐ๋จํ๋ค ๋จ์ : ๋ด๋ถ ๋จํธํ ๋ฐ์ Dynamic Partitioning : ํ๋ก์ธ์ค ํฌ๊ธฐ์ ๋ง๊ฒ ํ ๋น
์ฅ์ : ๋ด๋ถ ๋จํธํ ๋ฐ์ X ๋จ์ : ์ธ๋ถ ๋จํธํ ๋ฐ์ (compaction์ ํตํด ํด๊ฒฐ ๊ฐ๋ฅ but, overhead๊ฐ ํฌ๋ค) Dynamic Partition Placement Algorithm
First-fit : ์ฒ์์ผ๋ก ๋ง๋ ๊ณต๊ฐ์ ๋ฃ๋๋ค ์ฅ์ : ๋น ๋ฅด๋ค ๋จ์ : ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ด ์ข์ง ์๋ค Best-fit : ๋๊น์ง ์กฐ์ฌํด์ ๊ฐ์ฅ ๋น์ทํ ๊ณณ์ ํ ๋น ์ฅ์ : ๋๋ฆฌ๋ค ๋จ์ : ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ด ์ข๋ค Buddy System Allocation 2^k ํฌ๊ธฐ์ ๊ณต๊ฐ์ ํ ๋น Deallocation Buddy ํ ์์ด ๋ชจ๋ free์ธ ๊ฒฝ์ฐ, ํฉ์น๋ค (ํ์ Overhead๋ฅผ ์ค์ด๊ธฐ ์ํด) ์ฅ์ : ์ธ๋ถ ๋จํธํ๊ฐ ๊ฑฐ์ ์๋ค ๋จ์ : ๋ด๋ถ ๋จํธํ ๋ฐ์ Virtual Address Space Type of Memory Addresses Physical address : ์ค์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์ Logical address : ํ๋ก์ธ์ค๊ฐ ๋ณด๋ ์ฃผ์ Virtual address : Virtaul memory์ Logical address Relative address (์ฃผ์ ๊ณ์ฐ ๋ฐฉ์) : ์๋์ ์ธ ์ฃผ์ Virtual Address Space ํฌ๊ธฐ : 4GB (32bit ์ปดํจํฐ) : 0x00000000 ~ 0xFFFFFFFF kernel - stack - heap - bss - data - code Address Binding Address binding instruction๊ณผ ๋ฐ์ดํฐ์ Physical address๋ฅผ ์์๋ด๋ ๊ฒ 3๊ฐ์ง ์ํฉ์ ์ผ์ด๋ ์ ์๋ค (Compile time, Load time, Execution time) Compile time binding Compileํ ๋, base address๋ฅผ ์๋ ค์ค์ผ๋ก์จ ๋ฏธ๋ฆฌ physical address๋ฅผ ๋ฃ์ด๋๋๋ค Logical address = Physical address ๋ฌธ์ ์ : Relocation ๋ถ๊ฐ (base address๊ฐ ๋ฐ๋๋ฉด ๋ค์ compile ํด์ผํจ) Load time binding Loadํ ๋, physical address๋ฅผ ๊ณ์ฐ Logical address = Physical address ๋ฌธ์ ์ : Relocation ๋ถ๊ฐ Execution time binding ์คํํ ๋, physical address๋ฅผ ๊ณ์ฐ Logical address != Physical address Relocation ์ผ์ด๋๋ ์ด์ : Swapping, Compaction Hardware for Execution Time Binding Base register : ์์ ์ฃผ์ Bounds register (limit register) : ๋ ์ฃผ์ Adder๊ฐ Base Register + releative address ๊ณ์ฐ Comparato๊ฐ Bounds Register์ ๋น๊ต ์์ญ ๋ฐ์ธ ๊ฒฝ์ฐ Segementation Fault(Trap) ๋ฐ์ Paging Paging ํ๋ก์ธ์ค๋ฅผ ๊ฐ์ ํฌ๊ธฐ์ ํ์ด์ง๋ก ๋๋๋ค page size = frame size = disk block size = 4KB Internal fragmentation ๋ฐ์ (๋ฌด์ ๊ฐ๋ฅ) Page Table PCB์ ์ ์ฅ ๋์ด์ ๊ด๋ฆฌ Virtual Memory ์ฌ์ฉ ์ N๊ณผ frame number๊ฐ ์์ฌ์ ์กด์ฌ Page number and offset Logical address = Page number + offset Page size 16 Bytes (128bit), 8 bit address์ธ ๊ฒฝ์ฐ ํ์ํ ์ฃผ์ ๊ฐ์ = 128 / 8 = 16๊ฐ offset = 4bit (2 ^ 4 = 16) page number = 8 - 4 = 4bit (๋จ๋ ๊ฑฐ) Address translation in Paging Logical address -> Physical address offset์ ๊ทธ๋๋ก, page ๋ฒํธ๋ง frame ๋ฒํธ๋ก ๋ฐ๊พผ๋ค Segmentation ํ๋ก์ธ์ค๋ฅผ ๋ค๋ฅธ ํฌ๊ธฐ์ ๋
ผ๋ฆฌ์ ๋จ์์ธ ์ธ๊ทธ๋จผํธ๋ก ๋๋๋ค Dynamic partitioning๊ณผ ์ ์ฌ ๋
ผ๋ฆฌ์ ์ผ๋ก ๋น์ทํ ๊ฒ๋ค์ ๋ฌถ๋๋ค. 09-Virtual-Memory Advantages of Virtual Memory Virtual Memory ์ ์ฒด ํ๋ก์ธ์ค๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ผ๊ฐ ํ์๊ฐ ์๋ค ๋ ๋ง์ ํ๋ก์ธ์ค ์์ฉ ๊ฐ๋ฅ -> swap ๋น๋ ๊ฐ์, ์ข์ ๋ฐ์์ฑ ์ ์ฒด ๋ฉ๋ชจ๋ฆฌ ๋ณด๋ค ํฐ ํ๋ก์ธ์ค๋ ์คํ ๊ฐ๋ฅ Types of Memory Real Memory address : Real address, Physical address, Absolute address Virtual Memory address : Logical address, Virtual address Execution of a Program Resident set : Main memory์ ์กด์ฌํ๋ ํ๋ก์ธ์ค ์งํฉ Main Memory์ ์๋ Page๊ฐ ํ์ํ ๊ฒฝ์ฐ -> Page fault (interrupt) ํด๋น ํ๋ก์ธ์ค block -> ๋ค๋ฅธ ํ๋ก์ธ์ค ์คํ -> Disk I/O ๋๋๋ฉด ๋ค์ ready Principle of Locality ํ๋ก์ธ์ค์ ํ๋ก๊ทธ๋จ ๋ฐ ๋ฐ์ดํฐ ์ฐธ์กฐ๋ ๋ญ์น๋ค๋ ์ฑ์ง Virtual Memory๊ฐ ํจ์จ์ ์ธ ์ด์ ์ค ํ ๊ฐ์ง Demand paging Demand paging Virtual Memory์ ๋๊ฐ์ง ๋ฐฉ๋ฒ Demand paging Demand segmentation : ๋๋ ค์ ์ฌ์ฉ ํ์ง ์๋๋ค Address Translation in demand paging Page table base register์ page table ์์ ์ฃผ์๋ฅผ ์ ์ฅ ๋งค๋ฒ 2๋ฒ์ฉ Main memory๋ฅผ accessํ ํ์ ์์ Page Table Entry P M R U W COW page frame number (p`) P : present(valid) bit : Main memory์ ์กด์ฌํ๋์ง ์ฌ๋ถ M : modified bit : ํ์ด์ง๊ฐ ์์ ๋์๋์ง ์ฌ๋ถ R : referenced bit : ํ์ด์ง๋ฅผ ์ ๊ทผํ์ ์๋์ง ์ฌ๋ถ U : user mode : User context์ ํด๋นํ๋์ง ์ฌ๋ถ W : writable : ํ์ด์ง๊ฐ ์ฐ๊ธฐ ๊ฐ๋ฅํ์ง ์ฌ๋ถ COW : copy-on-write : ํ์ด์ง๋ฅผ ๋ถ๋ชจ๋ ๊ณต์ ํ๋์ง ์ฌ๋ถ Modify Bit in page table M bit๊ฐ 0์ด๋ฉด ๋์คํฌ์ ๋ฐ์ํ์ง ์๊ณ ์ญ์ ๊ฐ๋ฅ Sharing of Pages ๊ฐ์ ํ์ด์ง๋ฅผ ๊ณต์ ํด์ผํ ๋, Page table์ ๊ฐ์ ์ฃผ์๋ฅผ ์ ์ฅ Multi-level Page Table Size of Page tabbles ํฐ ํ๋ก์ธ์ค๋ 1๊ฐ์ page table๋ก ์ฒ๋ฆฌ๋ถ๊ฐ -> Multi-level apge table Two-Level Scheme for 32-bit address 1๊ฐ์ Page Table์ด ์์ฉํ๋ ํ์ด์ง์๋ = 1K๊ฐ 4GB User address space = 1M๊ฐ์ ํ์ด์ง -> ํ์ด์ง ํ
์ด๋ธ์ด ๋ ํ์ Two-Level Paging Example Page number๊ฐ 2๊ฐ ์กด์ฌ page number1 : 10bit page number2 : 10bit page offset : 12bit Addres-Translation Scheme Page ํฌ๊ธฐ 4096B / Page tableํฌ๊ธฐ 4B = 1024 -> page number์ ๊ฐ์ = 10bit (2^10=1024) ํ์ด์ง์ ํฌ๊ธฐ 4096B์ด๊ธฐ ๋๋ฌธ์ -> Offset bit = 12bit (2^12=4096) Translation Lookaside Buffer Translation Lookaside Buffer ๊ณ์ธต์ด ๋ง์์ง๋ฉด ์๊ฐ์ด ์ค๋๊ฑธ๋ฆฐ๋ค TLB์ accessํ ์์๋๋ก ์ ์ฅ TLB๋ ๋ณ๋ ฌ๋ก ํ์, O(1)๋ก ํ์๊ฐ๋ฅ TLB ํ์ธ -> ์์ผ๋ฉด Page table ํ์ธ -> ์์ผ๋ฉด Page fault Effective Access Time Memory cycle = 1์ด๋ผ๊ณ ๊ฐ์ TLB ์ฝ๋ ์๊ฐ = $\varepsilon$ TLB hit ratio = $\alpha$ EAT = TLB์ ์์ ๋ ๊ฑธ๋ฆฌ๋ ์๊ฐ + ์์๋ ๊ฑธ๋ฆฌ๋ ์๊ฐ $$ EAT = (\varepsilon+1)\alpha + (\varepsilon+1+1)(1-\alpha) = 2+\varepsilon-\alpha $$ Page Replacement Replacement Policy Main Memory๊ฐ ๊ฝ์ฐจ๋ฉด page๋ฅผ swap out ์์ผ์ผํ๋ค Basic Replacement Algorithms FIFO ๊ฐ์ฅ ์ค๋๋ ํ์ด์ง๋ฅผ ๊ต์ฒด ๋นํจ์จ์ Optimal policy ๊ฐ์ฅ ๋์ค์ ์ฌ์ฉ๋ ํ์ด์ง๋ฅผ ๊ต์ฒด ๋์ค์ ์ด๋ค page๊ฐ ํ์ํ ์ง ์๋ ๊ฒฝ์ฐ ์ฌ์ฉ๊ฐ๋ฅ Least Recently Used (LRU) ๊ฐ์ฅ ์ค๋์ ์ ์ฌ์ฉ๋ ํ์ด์ง๋ฅผ ๊ต์ฒด ๋ง์ง๋ง์ผ๋ก ์ธ์ ์ฐ์๋์ง ํญ์ ์ฐพ์์ผ ํ๋ค -> Overhead ๋ฐ์ Clock Policy (Second change algorithm) ๋์๊ฐ๋ฉด์ user bit -= 1 user == 0์ด๋ฉด ๊ต์ฒด ํ์ด์ง๋ฅผ ์ฌ์ฉํ๋ฉด user ๋นํธ = 1 ์ฑ๋ฅ ๋น๊ต FIFO < Clock < LRU < OPT Enhanced Clock Policy U๋นํธ์ M๋นํธ์ ๋ฐ๋ผ ์ฐ์ ์์ ๋ถ์ฌ U = 0, M = 0 U = 0, M = 1 U = 1, M = 0 U = 1, M = 1 Performance of Demand Paging Page Fault Rate = page fault ํ์ / page ๋ถ๋ฌ์ค๋ ํ์ Effective Access Time(EAT) = (1-p) x memory access + p x (page fault overhead + swap page out + swap page in + restart overhead)