๋ฐฐ๊ฒฝ ํ
์ปค ๋ถํธ์บ ํ์์ ํํ๋ก์ ํธ๋ฅผ ์งํ ์ค์ด๋ค. ์ฐ๋ฆฌ ํ์ ์ฃผ์ ๋ ํน์ ์ธ๋ฌผ์๊ฒ ์๋ด์ ๋ฐ๋ ๊ฒ ๊ฐ์ ๋ํ๋ฅผ ํ ์ ์๋ ์ฑ๋ด์ ๋ง๋๋ ๊ฒ์ด๋ค. ์ด๋ฅผ ์ํด ํน์ ์ธ๋ฌผ์ด ํ๋ ๋ง์ ๋ชจ์ ๋ฐ์ดํฐ์
์ผ๋ก ๋ง๋ค๊ณ ์ด๋ฅผ 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); 1์ฃผ์ฐจ - ์์ ์ฌ ๊ต์๋ - ์ฒจ๋จ๋ถ์ผ ํ์ ์ตํฉ๋ํ์ฌ์
(COSS: Convergence and Open Sharing System) ์ถ์ง๋ฐฐ๊ฒฝ : ๋์งํธ ์ ํ, ๊ธ๋ก๋ฒ ๊ฒฝ์ ์ฌํ์ ๋ฐ๋ผ ์ ๊ธฐ์ ์ด๊ฒฉ์ฐจ ํ๋ณด ๋ฐ ๊ธ์ฆํ๋ ์ ์ฐ์
์ธ๋ ฅ ์์์ ๋์ํ ์ ์๋ ์ธ์ฌ ์์ฑ ์ถฉ๋จ๋ํ๊ต : ๋ธ๋ก์ฒด์ธ ๋ถ์ผ ํนํ, ์ฐ๊ตฌํ๋ ฅ(์ฐ๊ตฌ๋จ์ง) ์ค์ฌ ํนํ 5๊ฐ ์ต๋ณตํฉ์ฐฝ์์ ๊ณต ๋ธ๋ก์ฒด์ธ์ตํฉ์ ๊ณต ์ฌ์ด๋ฒ๋ณด์์ตํฉ์ ๊ณต ํด๋ผ์ฐ๋์ตํฉ์ ๊ณต ๋ฐ์ดํฐ๋ณด์ํ์ฉ์ตํฉ์ ๊ณต : ์ปดํจํฐ ๋น์ ๊ณต์ ๋์ ๊ฐ์ธ์ ๋ณด๋ณดํธ์ตํฉ์ ๊ณต 25-1ํ๊ธฐ ์ถฉ๋จ๋ํ๊ต ๊ฐ์ค ๊ณผ๋ชฉ ๋ธ๋ก์ฒด์ธ ๊ฐ๋ก ๋ธ๋ก์ฒด์ธ ํ๋ก๊ทธ๋๋ฐ ๋์งํธ ์์ฐ๊ณผ ๋ธ๋ก์ฒด์ธ ํ์์ง์ ํ์ ์ตํฉ๋ํ ํ์ ์ทจ๋ ์ฅํ๊ธ ์ง์ ์ ๋ฌธ๊ฐ์ ๊ต๋ฅ ๊ธฐํ ํ์ต๊ธฐ๊ธฐ ์ง์ ํ์ฅ์ค์ต ๊ธฐํ 3์ฃผ์ฐจ - ๊นํ์ ๊ต์๋ AI๊ธฐ์ ์ ์๋ฒ ๋๋ ์์คํ
ํ ์ด์ Privacy (๊ฐ์ธ์ ๋ณด ๋ณดํธ) Latency (์ง์ฐ์๊ฐ) Cost (๋น์ฉ) Embedding Resnet Resnet์ ์๋ฒ ๋๋ ์์คํ
์ ์ ์ฉํจ
Resnet : ํฉ์ฑ๊ณฑ ์ ๊ฒฝ๋ง ๋ชจ๋ธ ์์จ์ฃผํ ์๋์ฐจ์์์ ๋ฅ๋ฌ๋ ๊ตฌํ Image Classification DNN and MAC operation DNN : Deep Neural Network MAC : Multiply and Accumulate ์๋ฒ ๋๋ AI ํ๋์จ์ด Qualcomm Hexagon DSP Performance with low power ๊ณ ์ MAC ๊ธฐ๋ฐ ํ๋ก์ธ์ Apple Neural Engine ๋ด๋ด๋ท ๊ฐ์๊ธฐ์ MMA ๊ธฐ๋ฐ ๋ณ๋ ฌ์ฒ๋ฆฌํ GPU ํฌํจ Nvidia Jetson ๋ค์์ PE ๊ธฐ๋ฐ MMA ๊ฐ์ํ ๋ณ๋ ฌ์ฒ๋ฆฌ GPU ์์ํ, ํ๋ฃจ๋ ํ๋์จ์ด ์ง์ ์ต์ ํ SW ์คํ ์ง์ Nvidia Xavier NX ์ปดํจํฐ Nvidia Jetson ์๋ฆฌ์ฆ ์ค ํ๋
Tensor Processing Unit (TPU) Google ์ฌ์์ ๊ฐ๋ฐํ ๋ด๋ดํ๋ก์ธ์ ๊ฒ์์์ง, ์ํ๊ณ ์ ์ฌ์ฉ Google TPU : High-level Architecture FPGA๊ธฐ๋ฐ ๊ฐ์๊ธฐ (Accelerator) ๋๋ฉ์ธ๊ณผ ์์ฉ์ ํนํ๋ ๊ฐ์ํ๋ก๋ฅผ FPGA๋ก ๊ตฌํํ๊ณ ์ํํธ์จ์ด ์คํ์ ์ ๊ณต Microcontrollers(MCU) ์ ์ด์ฉ ์๋ฒ ๋๋ ํ๋ก์ธ์๋ก ์ฐ์ฐ ์ฑ๋ฅ์ด ๋งค์ฐ ๋ฎ์ผ๋ฉฐ, AI๋ฅผ ์ํ ๊ฐ์๊ธฐ๋ฅ์ ์์ง๋ง, ๋ชจ๋ธ ๊ฒฝ๋ํ, ์์ถ์ ํตํด ์ต์ ํ๋ฅผ ์ ์ฉ ์ค์๊ฐ ์จ๋ณด๋ AI ์ปดํจํ
CESL์ ์ฐ๊ตฌ ํ๋ ์์ํฌ ์์ด DNN ์ถ๋ก ๊ฐ๋ฅํ๊ฒ ํ๊ธฐ PyTorch, Tensorflow ์์ด ๋ชจ๋ ์ถ๋ก ๋ฃจํด์ C๋ก ๊ตฌํ ์ค์๊ฐ ์ถ๋ก ๋ฉ๋ชจ๋ฆฌ ๊ณ์ธต์ ํ์ฉํ๋ ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ต์ ํ CPU, GPU, DSP, NPU ์ต์ ์ํฌ๋ก๋ ํ ๋น์ ํตํ ๊ณ์ฐ ๊ฐ์ NN/LLM ์์ถ ์๋ ํฅ์ ์ ํ๋ ์์ค ์์ ์ฌ์ฉํ๋ ํ๋ ์์ํฌ TensorRT, ONNX RT Triton, GEMM, llama.cpp Darknet, OpenCL 4์ฃผ์ฐจ - ์กฐ์น๋ฒ ๊ต์๋ ์ด๋ก ์ ์ฐํ ์ํ์ ์ด์ฉํ์ฌ ๋ค์ํ ์ ์ฐํ ๊ด๋ จ ๋ฌธ์ ๋ค์ ์ ์ํ๊ณ ์ด๋ฅผ ํด๊ฒฐํ๋ ํ๋ฌธ
1. Integer Sequence Representation ์ํ๋ฒณ size๊ฐ |A|์ด๊ณ ๊ธธ์ด๊ฐ n์ธ integer sequence๋ฅผ ๊ฐ๋ฅํ ์์ ๊ณต๊ฐ์ ์ ์ฅํ๊ธฐ, ๋จ, ์ผ๋ฐ์ ์ธ array ์ฒ๋ผ random acess๊ฐ ๊ฐ๋ฅํด์ผ ํจ
๋ฐฉ๋ฒ 1: ๊ฐ alphabet ๋ง๋ค 4๋นํธ์ฉ ํ ๋นํจ -> 4n bits, O(1) access time ๋ฐฉ๋ฒ 2: ๊ฐ๋ฅํ ๋ชจ๋ 10^n๊ฐ์ sequence์ ๋ํด ์์๋๋ก ์ซ์๋ฅผ ๋ถ์ฌํจ $$ \left\lceil \log_2(10^n) \right\rceil = \left\lceil n \cdot \log_2 10 \right\rceil \approx \left\lceil 3.32n \right\rceil \text{ bits} $$ O(n) access time 2. Edit Distance edit distance : ๋ ๋ฌธ์์ด์ ๊ฐ๊ฒ ๋ง๋ค๊ธฐ ์ํด ํ์ํ ์ต์ํ์ ์ฐ์ฐ ํ์ ์ฐ์ฐ ์ข
๋ฅ ์ฝ์
(Insert) ์ญ์ (Delete) ๋์ฒด (Replace) SETH๊ฐ ๊ฑฐ์ง์ด ์๋๋ฉด $O(n^2)$ ๋ณด๋ค ๋นจ๋ฆฌ ๊ณ์ฐํ ์ ์์ SETH(Strong Exponential Time Hypothesis) : ๊ฐํ ์ง์ ์๊ฐ ๊ฐ์ค 3. Optimal online binary search tree ๋ชฐ๋ฃจ
4์ฃผ์ฐจ - ๊ถ์ง๊ทผ ๊ต์๋ - RNN/LSTM RNN (Recurrent Neural Network) $$ h_t = f(Vx_{t} + Ah_{t-1}) $$
f: tanh $x_t$: ํ์ฌ ์
๋ ฅ $h_{t-1}$: ๊ณผ๊ฑฐ์ ๋ณด LSTM (Long Short Term Memory) ์ด์ ์ ์
๋ ฅ ์ ๋ณด๊ฐ ์ค๋ ๊ธฐ์ต๋๋๋ก ๊ตฌ์กฐ ๊ฐ์
Attention Network ๋์ฝ๋์์ ์ถ๋ ฅ ๋จ์ด๋ฅผ ์์ํ๋ ๋งค time step๋ง๋ค, ์ธ์ฝ๋์์์ ์ ์ฒด ์ธํ์ ํ ๋ฒ ๋ ์ฐธ๊ณ
Transformer RNN์์ด Attention๋ง์ผ๋ก Encoder์ Decoder๋ฅผ ์ค๊ณ
๊ธฐ๋ณธ ๊ตฌ์กฐ : ๋ค์ธต ๊ตฌ์กฐ์ธ N๊ฐ์ encoder layer์ N๊ฐ์ decoder layer๋ก ๊ตฌ์ฑ
ํฌ์ง์
๋ ์ธ์ฝ๋ฉ (Positional Encoding)
RNN์ ๋จ์ด์ ์์น์ ๋ฐ๋ผ ์์ฐจ์ ์ผ๋ก ์
๋ ฅ์ ๋ฐ์ ๊ฐ ๋จ์ด์ ์์น ์ ๋ณด๋ฅผ ๊ฐ์ง ํธ๋์คํฌ๋จธ๋ ๋จ์ด ์
๋ ฅ์ ์์ฐจ์ ์ผ๋ก ๋ฐ๋ ๋ฐฉ์์ด ์๋๊ธฐ์ ๋จ์ด์ ์์น ์ ๋ณด๊ฐ ํ์ ์ํ์ ๋ชจ๋ ์์ ๊ณ self-attention์ด๋ผ๋ ํน๋ณํ ํํ์ attention์ ์์ง
self-attention Attention์ ์๊ธฐ์์ ์๊ฒ ์ํ
input data ์์ ์๋ ๋ฒกํฐ๋ค ๊ฐ์ similarities๋ฅผ ๊ณ์ฐ BERT (Bidirectional Encoder Representations from Transformers) Encoder๋ง ์ฌ์ฉ BART (Bidirectional and Auto-Regressive Transformers) Encoder์ Decoder ๋ชจ๋ ์ฌ์ฉ GPT (Generative pre-trained transformer) Decoder๋ง ์ฌ์ฉ ICL (In-context Learning) ๋ชจ๋ธ์ด ์ฃผ์ด์ง ์์๋ฅผ ๋ณด๊ณ ํ์ตํ๋ ๊ฒ
ICL์ LM์ด ํจํด์ ์ถ์ํ ๋ฅ๋ ฅ์ ๊ฐ์ง๊ณ ์๋ค๋ ๊ฒ์ ๋ณด์ฌ์ค
์ข
๋ฅ
Zero-shot : ์์ ์์ One-shot : ์์ ํ๋ Few-shot : ์์ ์ฌ๋ฌ ๊ฐ Zero-shot chain-of-thought (์๊ฐ์ ์ฌ์ฌ)
“Let’s think step by step"์ prompt์ ์ฝ์
-> GPT์ ์ถ๋ก ์ ์ ๋
RAG (Retrieval-Augmented Generation) ๊ฒ์ ์ฆ๊ฐ ์์ฑ
Open Model vs Closed Model Open Model : Llama Closed Model : ChatGPT 5์ฃผ์ฐจ - ๊นํ๊ธฐ ๊ต์๋ - ์ปดํจํฐ ๊ทธ๋ํฝ์ค ๋ฐ ํผํฉํ์ค ๊ธฐ์ ์๊ฐ ๋ฐ ํํฉ ์ปดํจํฐ ๊ทธ๋ํฝ์ค ๋ ๋๋ง ๋ฐ์ดํฐ๋ก๋ถํฐ ์ด๋ฏธ์ง๋ฅผ ๋ง๋ค์ด๋ด๋ ๊ธฐ์
On-line Rendering : ์ค์๊ฐ(>30fps)์ผ๋ก ์ด๋ฏธ์ง๋ฅผ ๋ง๋ค์ด๋ด๋ ๊ธฐ์ Off-line Rendering : ๋น์ค์๊ฐ์ผ๋ก ์ด๋ฏธ์ง๋ฅผ ๋ง๋ค์ด๋ด๋ ๊ธฐ์ On-line Rendering: Rasterization ์ปดํจํฐ ๊ทธ๋ํฝ์์, ๋ชจ๋ ๋ฌผ์ฒด๋ ์ผ๊ฐํ์ ์งํฉ์ผ๋ก ํํ๋จ
์ด๋ฌํ ์ผ๊ฐํ๋ค์ ์ผ๋ จ์ ๊ณผ์ ์ ๊ฑฐ์ณ ํ๋ฉด์ ํฝ์
๋ก ๋ณํํ๋ ๋ฐฉ์
Vertex Shader : ์ด๋์ ์ผ๊ฐํ์ด ์์ ๊ฒ์ธ๊ฐ?
Fragment Shader : ์ผ๊ฐํ ์์ ํฝ์
์ ์ด๋ค ์์ผ๋ก ์น ํ ๊ฒ์ธ๊ฐ?
์์ : vertex shader -> rasterization -> fragment shader -> output merger
GPU(Graphics Processing Unit) ๊ฐ๋จํ ๊ณ์ฐ์ ํ ์ ์๋ ์ฒ๋ฆฌ ์ฅ์น ์์ฒ-์๋ง๊ฐ๊ฐ ๋์์ ๋์์ ์
ฐ์ด๋๋ฅผ ์คํ Off-line Rendering: Ray/Path Tracing Ray/Path Tracing ๋น๊ณผ ๋ฌผ์ฒด์ ์ํธ์์ฉ์ Rasterization ์์ธํ ๊ณ์ฐ
๋์ผ๋ก ๋ค์ด์ฌ ๊ด์ ์ ์ญ์ผ๋ก ์ถ์ ํ์ฌ ์์์ ๊ณ์ฐ RTX Hybrid Rendering Rasterization + Ray Tracing, ๋ณ๋์ ์ฝ์ด ์ฌ์ฉ, ๋ฅ๋ฌ๋ ๊ธฐ๋ฐ ๊ธฐ์ ์ ์ฉ
Mixed Reality (ํผํฉํ์ค) ์ฉ์ด ํ์ค(Real Environment) : ์ฐ๋ฆฌ๊ฐ ์ด๊ณ ์๋, ๋ฌผ๋ฆฌ์ ์ค์ฒด๊ฐ ์๋ ํ๊ฒฝ ๊ฐ์ ํ์ค (Virtual Reality) : ๋ฌผ๋ฆฌ์ ์ผ๋ก ์กด์ฌํ์ง ์๋, ๊ฐ์์ผ๋ก ๋ง๋ค์ด์ง ํ๊ฒฝ ์ฆ๊ฐ ํ์ค (Augmented Reality) : ๋ฌผ๋ฆฌ์ ํ์ค์ ๋ฐฐ๊ฒฝ์ผ๋ก ๊ฐ์์ ๊ฐ์ฒด๋ฅผ ์ฆ๊ฐ์ํจ ํ๊ฒฝ ํผํฉ ํ์ค (Mixed Reality) : ๋ฌผ๋ฆฌ์ ํ์ค๊ณผ ๊ฐ์์ ๊ฐ์ฒด๊ฐ ํผ์ฌ๋์ด ์๋ ํ๊ฒฝ (AR์ ํ์ฅ ํํ) Buzzword ํ์ฅ ํ์ค(eXtended Reality) : MR์ VR๊น์ง ํ์ฅํ ๊ฐ๋
๊ณต๊ฐ ์ปดํจํ
(Spatial Computing) : Apple์์ ์ ์ํ, ๋ฉํ๋ฒ์ค์ ๋์งํธ ํธ์๊น์ง ํฌํจํ๋ ๊ฐ๋
๊ถ๊ทน์ ์ธ ๋ชฉํ ์ธ๊ฐ์ ์ฃผ์ ๊ฐ๊ฐ๋ค์ ํตํด ์ง์ง์ฒ๋ผ ๋๋ผ๊ฒ ํ๋ ๊ฒ HMD (Head Mounted Display) ์์
์ ์ผ๋ก ๊ฐ์ฅ ์ฑ๊ณตํ VR ์ฅ์น์ ํํ
XR๋ก์ ํ์ฅ์ด ๊ฐ๋ฅํ๋๋ก ์ ๋ฉด๋ถ์ ์นด๋ฉ๋ผ๋ก ์ดฌ์๋ ์์์ ๋ค์ ๋์คํ๋ ์ด์ ํฌ์ฌ HMD์ ์๋ฆฌ ์์ ๊ณ ํด์๋ ๋์คํ๋ ์ด๊ฐ ๋ ์์ ์์ -> ์ด์ ์ ๋ง์ถ ์ ์์ ๋ ์ฆ(๋๋ณด๊ธฐ)๋ฅผ ์ฌ์ฉํ์ฌ ์์ ๋ฉ๋ฆฌ ๋๋ฉฐ, ๋์ ์์ผ๊ฐ์ ์ ๊ณตํ ์ ์๋๋ก ํจ ์์ ์์ฐจ๋ฅผ ์ฌ์ฉํด ๊ฑฐ๋ฆฌ๋ฅผ ์ธ์งํ ์ ์๋๋ก ํด๋น ์ฅ์น๋ฅผ ์ ๊ณต HMD์ Tracking Outside-in Tracking : ์ธ๋ถ ์ผ์๊ฐ HMD ์ฅ์น๋ฅผ ๊ด์ฐฐํ์ฌ ํธ๋ํน Inside-out Tracking : HMD์ ์ค์น๋ ์ผ์๋ค๋ก ์ธ๋ถ๋ฅผ ๊ด์ฐฐํ์ฌ ํธ๋ํน XR HMD Optical see-through : ๋ฐํฌ๋ช
ํ ๋์คํ๋ ์ด ๋ด๋ถ์์ ๋น์ ๋ฐ์ฌํ์ฌ ์ ๋ฌ Video see-through : ์ ๋ฉด๋ถ์ ์นด๋ฉ๋ผ๋ก ์ฐ์ ์ด๋ฏธ์ง์ ๊ฐ์์ ๋ฌผ์ฒด๋ฅผ ๋ํด ๋ ๋๋ง 5์ฃผ์ฐจ - ์ํฌ์ฒ ๊ต์๋ - AI/ML ์์คํ
์ฐ๊ตฌ ๋ํฅ AI/ML ์์คํ
์ ํจ์จ์ฑ Distributed Training
ํ์ค์์๋ hybrid parallelism์ ์ฌ์ฉ
Data Parallelism : ๋ฐ์ดํฐ๋ฅผ ๋๋์ด ๊ฐ ๋
ธ๋์์ ํ์ต Model/Pipeline Parallelism : ๋ชจ๋ธ์ ๋๋์ด ๊ฐ ๋
ธ๋์์ ํ์ต Tensor parallelism : ํ
์๋ฅผ ๋๋์ด ๊ฐ ๋
ธ๋์์ ํ์ต Sequence parallelism : ํ ํฐ์ ๋๋์ด ๊ฐ ๋
ธ๋์์ ํ์ต AI/ML ์์คํ
์ ์ ๋ขฐ์ฑ Data Privacy ํด๋ผ์ฐ๋๋ ์ฃ์ง์์ ํ์ต์ด ์ด๋ฃจ์ด์ง๋ ๊ฒฝ์ฐ, ๋ฐ์ดํฐ๊ฐ ์ ์ถ๋ ์ ์์
Distributed Learning Federated Learning : ๋ฐ์ดํฐ๋ ํด๋ผ์ฐ๋์ ๋๊ณ , ๋ชจ๋ธ๋ง ์ฃ์ง์์ ํ์ต ์๋ฒ๊ฐ ์ฅ์น์ ๋ชจ๋ธ์ ์ ์ก ์ฌ์ฉ์์ ๋ฐ์ดํฐ๋ก ์ฅ์น์์ ๋ชจ๋ธ์ด ํ์ต ๊ฐ ์ฅ์น๊ฐ ๋ชจ๋ธ์ N๋ฒ ์
๋ฐ์ดํธ ์
๋ฐ์ดํธ ๋ ๋ชจ๋ธ์ด ์๋ฒ์ ์ ์ก ๋ชจ๋ธ์ด ์๋ฒ์์ ํฉ์ณ์ก๋ค๊ฐ, ๋ค์ ์ฅ์น์ ์ ์ก Split Learning Centralized and distributed neural network training Peer-to-peer training for distributed learning Decentralized Learning Swarm learning Gossip Learning Model Fairness ๋ชจ๋ธ์ด ํน์ ์ง๋จ์ ๋ํด ํธํฅ๋์ง ์๋๋ก ํ๋ ๊ฒ
Reliability Machine Unlearning ๋ชจ๋ธ์ด ํน์ ๋ฐ์ดํฐ๋ฅผ ์๋๋ก ํ๋ ๊ฒ
Robustness Model Poisoning์ ๋ํ ๋ฐฉ์ด
6์ฃผ์ฐจ - ๋ฐ์งํ ๊ต์๋ - Edge ์ปดํจํ
ํ๊ฒฝ ์ธ๊ณต์ง๋ฅ ์์ฉ ์ฐ๊ตฌ Edge Computing ์ค์ ์๋ฒ ๋์ Edge ์ปดํจํฐ๊ฐ ๋ฐ์ดํฐ๊ฐ ์์ฑ๋๋ ๊ณณ ํน์ ์ฒ๋ฆฌ๊ฐ ํ์ํ ๊ณณ ๊ทผ์ฒ์์ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ ๊ฐ๋
Edge Computing์ ์ฅ์ ์ง์ฐ์๊ฐ ์ ์ -> ๋ฐ์ดํฐ๋ฅผ ์ค์ ์๋ฒ์ ๋ณด๋ผ ํ์ ์์, ์ฒ๋ฆฌ๋ ๊ฒฐ๊ณผ๋ฅผ ๊ธฐ๋ค๋ฆด ํ์ ์์ ํต์ ์ฐ๊ฒฐ ๋ถํ์ ๋คํธ์ํฌ ํธ๋ํฝ ๊ฐ์ ๋์ ํ์ฅ์ฑ -> ์ผ์/ํ๋ซํผ ์๋ฅผ ๋๋ฆฌ๋ ๋ถ๋ด์ด ์ ์ ๊ฐ์ธ์ ๋ณด ๋ฐ ๋ณด์ ๊ฐํ -> ๋ฏผ๊ฐํ ๋ฐ์ดํฐ๋ฅผ ์ ์กํ ํ์ ์์ ์งํฅํ๋ ๊ฒ ๋ฐ์ดํฐ๋ฅผ ๋ ์์งํ์ง ์๊ณ ๋์ผํ ๋ชจ๋ธ์์ ์ ํ๋๋ฅผ ๋์ด๊ณ ์ถ๋ค -> ๋ฐ์ดํฐ ์ฆ๊ฐ/์์ฑ ๋์ผํ ์๋, ์ฑ๋ฅ์ ๋ ๋์ ์ ํ๋๋ฅผ ์ป๊ณ ์ถ๋ค -> ๋ชจ๋ธ ๊ตฌ์กฐ ๊ฐ์ ์ฐ๊ตฌ ๊ณผ์ ๊ฐ์ค -> ์คํ ์ค๊ณ -> ์คํ ์ํ -> ๊ฒฐ๊ณผ ๋ถ์ Multitask Learning ํ๋์ ๋ชจ๋ธ์ด ์ฌ๋ฌ ๊ฐ์ task๋ฅผ ๋์์ ํ์ตํ๋ ๋ฐฉ๋ฒ
๊ฐ์ข
์ฐ๊ตฌ ๋ฐ์ดํฐ ์ฆ๊ฐ ๊ธฐ์กด์ ํ๋๋ ๋ฐ์ดํฐ๋ฅผ ์ด์ฉํด ๋ฐ์ดํฐ์ ๋ณํ์ ๊ฐํ์ฌ ๋ชจ๋ธ์ ์ผ๋ฐํ ์ฑ๋ฅ์ ๋์ด๋ ๋ฐฉ๋ฒ
๊ฐ์ ๋ฐ์ดํฐ ์์ฑ/ํ์ฉ ํ์ค๊ณผ ์ ์ฌํ ๊ฐ์ ๋ฐ์ดํฐ๋ฅผ ํ์ฉํ์ฌ ํ์ตํ ๋ชจ๋ธ์ ํ์ค์ ์ ์ฉ
์ ๋ณด ์ตํฉ ์ด๋ค ์๊ฐ์ ์ธ ์ ๋ณด๋ฅผ ์ ๋ถ์ํ๋ ์๊ณ ๋ฆฌ์ฆ์ ๋ง๋ฆ ์ด์ ํ์ง Reconstruction ๊ธฐ๋ฐ : ์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ์ฐจ์ ์ถ์ -> ์ฐจ์ ํ์ฅํ์ฌ ๋ณต์ ๊ฐ๋ฅ์ฑ์ผ๋ก ๋ณต์ ๋ถ๊ฐ๋ฅํ ๊ฒฝ์ฐ/๋ณต์ ๋ฐ์ดํฐ์ ์๋ณธ ์ฐจ์ด๊ฐ ํฐ ๊ฒฝ์ฐ ์ด์์ผ๋ก ํ๋ณ Prediction ๊ธฐ๋ฐ : ์
๋ ฅ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ฏธ๋๋ฅผ ์์ธก -> ํด๋น ์์ธก๊ณผ ์ค์ ๊ฐ์ ์ฐจ์ด๊ฐ ํฐ ๊ฒฝ์ฐ ์ด์์ผ๋ก ํ์ง Representation ๊ธฐ๋ฐ : ํน์ ํํ ๊ณต๊ฐ์ผ๋ก ๋ฐ์ดํฐ ๋งตํ -> ํํ ๊ณต๊ฐ์์์ ๊ฑฐ๋ฆฌ/๋ฐ๋ ๊ธฐ๋ฐ์ผ๋ก ํด๋ฌ์คํฐ์์ ๋ฒ์ด๋ ๋ฐ์ดํฐ๋ฅผ ์ด์์ผ๋ก ํ์ง ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ๊ณ ๋ คํ๋์ง ์ฌ๋ถ์ ๋ฐ๋ฅธ ํ
์คํธ์ ๋ถ๋ฅ ๋ธ๋๋ฐ์ค ํ
์คํธ ํ์ดํธ๋ฐ์ค ํ
์คํธ ๋ชฉ์ ๊ณผ ๋ฒ์์ ๋ฐ๋ฅธ ํ
์คํธ์ ๋ถ๋ฅ ์ํ ์์์ ๋ฐ๋ผ ์์ฑํด๋ณด์๋ค. 1. ๋จ์ ํ
์คํธ (Unit Test) ๊ฐ์ฅ ์์ ๋จ์ ์์ค(๋ชจ๋, ํจ์, ํด๋์ค)์ ํ
์คํธ
2. ํตํฉ ํ
์คํธ (Integration Test) ๋ชจ๋์ ํตํฉํ๋ ๊ณผ์ ์์, ๊ฐ ๋ชจ๋ ๊ฐ์ ์ธํฐํ์ด์ค์ ๊ด๋ จ๋ ๊ฒฐํจ์ด ์๋์ง ํ
์คํธ
Top-down : ์์ ๋ชจ๋๋ถํฐ ํ์ ๋ชจ๋๋ก ํตํฉํ๋ฉฐ ํ
์คํธ Bottom-up : ํ์ ๋ชจ๋๋ถํฐ ์์ ๋ชจ๋๋ก ํตํฉํ๋ฉฐ ํ
์คํธ Big-bang : ๋ชจ๋ ๋ชจ๋์ ํ๋ฒ์ ํตํฉํ์ฌ ํ
์คํธ Threads : ์ค์ ๋ชจ๋์ ๋จผ์ ๊ตฌํํ๊ณ ํตํฉํ ๋ค, ๋ณด์กฐ์ ์ธ ๋ชจ๋์ ๊ตฌํ ํ ํตํฉํ๋ ๋ฐฉ์ 3. ์์คํ
ํ
์คํธ (System Test) ์ ์ฒด ์์คํ
์ด ์๊ตฌ์ฌํญ์ ๋ง์กฑํ๋์ง ํ
์คํธ (HW+SW)
์ฃผ์ ๊ด์ ๊ธฐ๋ฅ ํ
์คํธ ๋น๊ธฐ๋ฅ ํ
์คํธ : ์ฑ๋ฅ, ์์ ์ฑ, ๋ณด์, ์ฌ์ฉ์ฑ ๋ฑ ๊ธฐํ ๋น๊ธฐ๋ฅ์ ์ธ ์ธก๋ฉด์ ํ๊ฐ E2E ํ
์คํธ ํ๊ท ํ
์คํธ ํธํ์ฑ ํ
์คํธ : ๋ค์ํ ํ๊ฒฝ์์ ์ฌ๋ฐ๋ฅด๊ฒ ์๋ํ๋์ง ํ
์คํธ 4. ์ธ์ ํ
์คํธ (Acceptance Test) ์ฌ์ฉ์ ๊ด์ ์์ ์๊ตฌ์ฌํญ์ ๋ง์กฑํ๋์ง ํ
์คํธ
์คํ ์ฌ๋ถ์ ๋ฐ๋ฅธ ํ
์คํธ์ ๋ถ๋ฅ ์ ์ ํ
์คํธ ๋์ ํ
์คํธ ๋ด๋ถ ๊ตฌ์กฐ๋ฅผ ๊ณ ๋ คํ๋์ง ์ฌ๋ถ์ ๋ฐ๋ฅธ ํ
์คํธ์ ๋ถ๋ฅ ๋ธ๋๋ฐ์ค ํ
์คํธ ํ์ดํธ๋ฐ์ค ํ
์คํธ ์ ์ ํ
์คํธ SW๋ฅผ ์คํํ์ง ์๊ณ ํ
์คํ
ํ๋ ๊ธฐ๋ฒ
๋ฆฌ๋ทฐ ์ฌ๋ฌ ์ ๋ฌธ๊ฐ๋ค์ด ๋ชจ์ฌ ์ฝ๋๋ฅผ ํฌํจํ SW ๊ฐ๋ฐ ๋ฐ ์ฐ์ถ๋ฌผ์ ๊ฒํ ํ๊ณ ํ
์คํ
ํ์ฌ ๊ฒฐํจ์ ๊ฒ์ถํ๋ ๋ฐฉ๋ฒ
Inspection ์ ๋ฌธ์ ์ธ inspection team์ด ์ ํํ๋ ๋ฐฉ์์ผ๋ก defect๋ฅผ ์ฐพ๋ ๋ฆฌ๋ทฐ ๊ธฐ๋ฒ Planning -> Overview -> Preparation -> Meeting(Inspection) -> Rework -> Follow-up Peer Review (Technical Review) ๊ฐ๋ฐํ์ด ์ฃผ๋ํ์ฌ ์ง์ ๋ชจ์ฌ ์ํํ๋ ๋ฆฌ๋ทฐ ๊ธฐ๋ฒ PL ๋๋ TL์ด ์ฃผ๋ํ์ฌ ๋ฆฌ๋ทฐ ๋์์ ์ ์ , ๊ฐ๋ฐ์์๊ฒ ๋ฆฌ๋ทฐ ์์ฒญ Walkthrough Peer Review์ ์ ์ฌํ๋ ๋ฌธ์ ์์ฑ์๊ฐ ์ฃผ๋ํ๋ ๊ฐ๋ฒผ์ด ๋ง๋จ ํํ ์ ์ ๋ถ์ (๋ฌด๊ธฐ์ฒด๊ณSW ๊ฐ๋ฐ ๋ฐ ๊ด๋ฆฌ ๋งค๋ด์ผ ๊ธฐ์ค) ์ฝ๋ฉ ๊ท์น
MISRA-C MISRA-C++ C# Coding conventions Code conventions for the Java Programming Language CWE(Common Weakness Enumeration) ์ ๊ฒ
์ผ๋ฐ์ ์ธ SW์ HW์ ๋ณด์ ์ฝ์ ์ ๋์ดํ ๊ณต์์ ์ธ ๋ฆฌ์คํธ
CWE-658 : C์ธ์ด CWE-659 : C++ CWE-660 : Java Code Metric ์ ๊ฒ
Cyclomatic Complexity : ์ ์ด ํ๋ฆ ๊ทธ๋ํ์ ๋ณต์ก๋ Number of call levels : ์กฐ๊ฑด๋ฌธ ์ค์ฒฉ์ ๊น์ด Number of function parameters Number of calling function : ํจ์๊ฐ ๋ช ๋ฒ ํธ์ถ๋๋๊ฐ Number of called functions : ํจ์๋ฅผ ๋ช ๋ฒ ํธ์ถํ๋๊ฐ Number of Executable code lines ๋์ ํ
์คํธ ๋ช
์ธ ๊ธฐ๋ฐ ํ
์คํธ (๋ธ๋๋ฐ์ค ๊ธฐ๋ฒ)
๋๋ฑ ๋ถํ ๊ฒฝ๊ณ๊ฐ ๋ถ์ ๊ฒฐ์ ํ
์ด๋ธ ํ
์คํธ ์ํ ์ ์ด ํ
์คํธ ๋ถ๋ฅ ํธ๋ฆฌ ๊ธฐ๋ฒ ์กฐํฉ ํ
์คํธ ์๋๋ฆฌ์ค ํ
์คํธ … ๊ตฌ์กฐ ๊ธฐ๋ฐ ํ
์คํธ (ํ์ดํธ๋ฐ์ค ๊ธฐ๋ฒ)
Statement Coverage Decision Coverage (Branch Coverage) Condition Coverage MC/DC Coverage Path Coverage Fuzzing ํ
์คํธ ์ ํจํ, ์์์น ์์ ๊ฐ๋ค์ ๋ฌด์์๋ก ๋์
ํ๋ ํ
์คํธ ๊ธฐ๋ฒ
๋ณํ ๊ธฐ๋ฐ Fuzzing (Dumb Fuzzing)
์
๋ ฅ ์ํ์ Fuzzing ๋๊ตฌ์ ์ ๊ณต, Fuzzing ๋๊ตฌ๊ฐ ์ด๋ฅผ ๋ณํ์์ผ๊ฐ๋ฉด์ ํ
์คํธ
์ฅ์ ์ฝ๊ณ ๋น ๋ฅด๊ฒ ๊ตฌํ์ด ๊ฐ๋ฅ ์
๋ ฅ ๊ตฌ์กฐ์ ๋ํ ๋ถ์์ ํ์ง ์์๋ ๋จ ๋จ์ ๋ฏธ๋ฆฌ ์ ์๋ ๊ตฌ์กฐ๊ฐ ํ์ํ๊ฑฐ๋ ์ฒดํฌ์ฌ์ด ํฌํจ๋์ด ์๋ ๊ฒฝ์ฐ ์ ํจํ ์
๋ ฅ์ ์์ฑํ๋๋ฐ ์ด๋ ค์์ด ์กด์ฌ ์์ฑ ๊ธฐ๋ฐ Fuzzing (Smart Fuzzing)
๋์ ์์คํ
์ ์
๋ ฅ์ํฌ ๋ฐ์ดํฐ๋ฅผ Fuzzing ๋๊ตฌ๊ฐ ์์ฑ
์ฅ์ ๋ ๋์ Coverage๋ก ์ด์ด์ง๋ ํ
์คํธ์ผ์ด์ค๋ฅผ ์์ฑ ๋จ์ ์
๋ ฅ ๋ชจ๋ธ์ ๋ํ ์ดํด๋๊ฐ ์ ํ๋์ด์ผ ํจ ๊ตฌํ ๋์ด๋๊ฐ ๋์ ํ๊ท ํ
์คํธ (Regression Test) ํ๊ท ํ
์คํธ๋ ์ํํธ์จ์ด์ ์๋ก์ด ๋ฒ์ ์์ ๊ธฐ์กด ๊ธฐ๋ฅ์ด ์์๋์ง ์์๋์ง ํ์ธํ๋ ํ
์คํธ
ํ๊ท ๋ฒ๊ทธ(Regression Bug) : ์ด์ ์ ์กด์ฌํ์ง ์๋ ๋ฒ๊ทธ๊ฐ ๊ธฐ๋ฅ ์์ ์ด๋, ์๋ก์ด ๊ธฐ๋ฅ ์ถ๊ฐ๋ก ์ธํด ์๋ก์ด ๋ฒ์ ์์ ๋ฐ์ํ๋ ๋ฒ๊ทธ ํ๊ท ํ
์คํธ๋ ๋ฐ๋ณต์ ์ธ ์์
์ด ๋ง์ ์๋ํ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ์ฌ ํ
์คํธํ๋ ๊ฒ์ด ํจ์จ์ ํ๊ท ํ
์คํธ์ ์ข
๋ฅ Retest all ๊ธฐ๋ฒ : ๊ธฐ์กด์ ๋ชจ๋ ํ
์คํธ ์ผ์ด์ค๋ฅผ ๋ค์ ์คํํ์ฌ ์ ์ฒด ์์คํ
์ ๊ฒ์ฆํ๋ ๋ฐฉ๋ฒ Selective retest ๊ธฐ๋ฒ : ๋ณ๊ฒฝ๋ ๋ถ๋ถ์ ๋ํด์๋ง ์ ํ์ ์ผ๋ก ํ
์คํธ๋ฅผ ์ํํ๋ ๋ฐฉ๋ฒ Prirority ๊ธฐ๋ฒ : ์์คํ
์ ํต์ฌ ๊ธฐ๋ฅ์ ์ค์ฌ์ผ๋ก ์ฐ์ ์์๋ฅผ ์ ํ์ฌ ํ
์คํธํ๋ ๋ฐฉ๋ฒ FIRST ์์น ๋จ์ ํ
์คํธ์ 5์์น
Fast : ํ
์คํธ๋ ๋นจ๋ผ์ผ ํ๋ค. Independent : ํ
์คํธ๋ ์๋ก ๋
๋ฆฝ์ ์ด์ด์ผ ํ๋ค. Repeatable : ํ
์คํธ๋ ์ด๋ค ํ๊ฒฝ์์๋ ๋ฐ๋ณต ๊ฐ๋ฅํด์ผ ํ๋ค. Self-validating : ํ
์คํธ๋ ์ฑ๊ณต ๋๋ ์คํจ์ฌ์ผ ํ๋ค. (bool ๊ฐ) Timely : ํ
์คํธ๋ ์ ์์ ์์ฑํด์ผ ํ๋ค. (์ค์ ์ฝ๋๋ฅผ ๊ตฌํํ๊ธฐ ์ ์ ์์ฑ) 1. Agile ๋ฐฉ๋ฒ๋ก Agile ์ ์ธ๋ฌธ ์ฌ๋๊ณผ ์ํธ์์ฉ > ํ๋ก์ธ์ค์ ๋๊ตฌ ์๋ํ๋ ์ํํธ์จ์ด > ํฌ๊ด์ ์ธ ๋ฌธ์ ๊ณ ๊ฐ๊ณผ์ ํ๋ ฅ > ๊ณ์ฝ ํ์ ๋ณํ์ ๋ํ ๋์ > ๊ณํ์ ๋ฐ๋ฅด๊ธฐ Agile 12๊ฐ์ง ์์น ์ด๊ธฐ๋ถํฐ ์ง์์ ์ผ๋ก ๊ณ ๊ฐ์ ๋ง์กฑ ์๊ตฌ์ฌํญ ๋ณ๊ฒฝ ์์ฉ ์งง์ ๋ฐฐํฌ ์ฃผ๊ธฐ ๊ธฐํ์์ ๊ฐ๋ฐ์์ ํ์
๋๊ธฐ๋ถ์ฌ๋ ํ์๋ค๋ก ํ๋น๋ฉ ์ผ๊ตด๋ณด๊ณ ๋ํํ๊ธฐ ๋์๋๋ ์ํํธ์จ์ด๋ก ์ง์ฒ ์ธก์ ์ง์ ๊ฐ๋ฅํ ๊ฐ๋ฐ ์๋ ์ ์ง ์ข์ ๊ธฐ์ ๋ก ์ข์ ์ค๊ณํ๊ธฐ ๋จ์์ฑ : ํ์์๋ ์ผ ์ต์ํํ๊ธฐ ์๊ธฐ์กฐ์งํ ํ ์ ๊ธฐ์ ์ผ๋ก ํจ์จ์ฑ์ ํฅ์์ํค๊ธฐ Self-Organizing Team (์๊ธฐ์กฐ์งํ ํ) ์ค์ค๋ก ์์
์ ์ํํ๊ณ ํ๋ก์ธ์ค๋ฅผ ๊ด๋ฆฌํ๋ฉฐ ์งํ ์ํฉ์ ๋ชจ๋ํฐ๋งํ๋ ๋ฐฉ๋ฒ์ ์ค์ค๋ก ๊ฒฐ์ ํ๋ ํ
2. Scrum ๋ฐฉ๋ฒ๋ก ์ญํ PO(Product Owner) : ์ ํ ์ฑ
์์, ์ ํ ๋ฐฑ๋ก๊ทธ ๊ด๋ฆฌ SM(Scrum Master) : ์คํฌ๋ผ ๋ง์คํฐ, ์คํฌ๋ผ ํ๋ก์ธ์ค๋ฅผ ์ ์ฉํ๊ณ ์ง์ Dev(Development Team) : ๊ฐ๋ฐํ, ์คํ๋ฆฐํธ ๋ฐฑ๋ก๊ทธ๋ฅผ ๊ฐ๋ฐ Stakeholder : ์ดํด๊ด๊ณ์, ์ ํ์ ๋ํ ํผ๋๋ฐฑ ์ ๊ณต ์ฉ์ด Product Backlog : ์๊ตฌ์ฌํญ์ธ ์ฌ์ฉ์ ์คํ ๋ฆฌ ์งํฉ User Story : ์ฌ์ฉ์๊ฐ ์ฌ์ฉํ๋ ๊ด์ ์์ ์ ๊ณตํ๋ ๊ฐ์น์ ๋ํ ์ค๋ช
์๋ฃ ๊ธฐ์ค (Definition of Done), ์ธ์ ๊ธฐ์ค (Acceptance Criteria) : ์ฌ์ฉ์ ์คํ ๋ฆฌ๊ฐ ์๋ฃ๋์๋์ง ํ๋จํ๋ ๊ธฐ์ค Sprint Planning Meeting : sprint ๋ชฉํ์ sprint backlog๋ฅผ ๊ณํํ๋ ํ์ Sprint Backlog : sprint ๋์ ๊ฐ๋ฐํ ์์
๋ชฉ๋ก Kanban Board : ์์
์ ์๊ฐ์ ์ผ๋ก ์
๋ฌด ์ํ, ํ๋ฆ์ ๋ณด์ฌ์ฃผ๋ ๊ฒ์ํ Backlog To Do In Progress Verify Done Product Backlog Sprint Backlog Sprint Backlog Sprint Backlog Sprint Backlog Daily Scrum : ์ด์ ํ ์ผ, ์ค๋ ํ ์ผ, ๋ฌธ์ ์์๋ฅผ ๊ณต์ ํ๋ ํ์ Sprint Review : ์คํ๋ฆฐํธ ๋ง์ง๋ง ๋ ๊ฐ๋ฐ์๊ฐ ๊ฐ๋ฐํ ๋ด์ฉ์ Stakeholder, Client, PO์๊ฒ ์์ฐํ๊ณ ๊ฒํ Sprint Retrospective (์คํ๋ฆฐํธ ํ๊ณ ) : ์คํ๋ฆฐํธ ๋์ ๊ฐ์ ํ ์ ์ ์ฐพ๊ณ ๊ฐ์ ๋ฐฉ์์ ์ ์ ์งํ Velocity Chart : ์คํ๋ฆฐํธ ๋ณ๋ก ์๋ฃํ ์์
๋์ ๋ณด์ฌ์ฃผ๋ ์ฐจํธ Burndown chart : ์คํ๋ฆฐํธ ๋ณ๋ก ๋จ์ ์์
๋์ ๋ณด์ฌ์ฃผ๋ ์ฐจํธ