<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0">
  <channel>
    <title>행복을 찾아서</title>
    <link>https://blog.realbro.dev/</link>
    <description>realbro의 블로그입니다</description>
    <language>ko</language>
    <pubDate>Thu, 19 Nov 2026 23:14:34 +0900</pubDate>
    <generator>TISTORY</generator>
    <ttl>100</ttl>
    <managingEditor>realbro.noh</managingEditor>
    <image>
      <title>행복을 찾아서</title>
      <url>https://tistory1.daumcdn.net/tistory/4885705/attach/daf8edb121914d6c81762caaf1b1b718</url>
      <link>https://blog.realbro.dev</link>
    </image>
    <item>
      <title>Integer Partition</title>
      <link>https://blog.realbro.dev/65</link>
      <description>&lt;h3 id=&quot;what-is-an-integer-partition&quot; data-ke-size=&quot;size23&quot;&gt;What is an integer partition?&lt;/h3&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;I encountered an interesting problem called &lt;b&gt;integer partition&lt;/b&gt; while reading Math Girls 1. It&amp;rsquo;s about counting the ways to express a positive integer as a sum of positive integers, where order doesn&amp;rsquo;t matter. The book introduces this using an analogy: how many ways can you pay N cents using coins of any denomination (1 cent, 2 cents, 3 cents, and so on)?&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;For example,&lt;/p&gt;
&lt;p style=&quot;text-align: center;&quot; data-ke-size=&quot;size16&quot;&gt;P(1) = 1 : &amp;nbsp;1 = 1&lt;br /&gt;P(2) = 2 : &amp;nbsp;2 = 2 = 1 + 1&lt;br /&gt;P(3) = 3 : &amp;nbsp;3 = 3 = 2 + 1 = 1 + 1 + 1&lt;br /&gt;P(4) = 5 : &amp;nbsp;4 = 4 = 3 + 1 = 2 + 2 = 2 + 1 + 1 = 1 + 1 + 1 + 1&lt;/p&gt;
&lt;h3 id=&quot;solution&quot; data-ke-size=&quot;size23&quot;&gt;Solution&lt;/h3&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;Although I tried to find a closed-form formula for P(n), I failed. However, I discovered a recurrence relation that allows me to compute it using programming.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;To derive this relation, let&amp;rsquo;s use the coin payment analogy. We can divide the partitions of n into cases based on the largest number used. For instance, some partitions use n as their largest part, others use n-1 as their largest part, and so on down to partitions using only &amp;lsquo;1&amp;rsquo;s.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;To formalize this, I&amp;rsquo;ll introduce a restricted partition P(n, k), which counts the partitions of n using only integers less than or equal to k. Then the total number of partitions is:&lt;/p&gt;
&lt;p style=&quot;text-align: center;&quot; data-ke-size=&quot;size16&quot;&gt;P(n) = P(n, n) &amp;nbsp; &amp;nbsp; (1)&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;The key insight is that P(n, k) satisfies the following recurrence relation:&lt;/p&gt;
&lt;p style=&quot;text-align: center;&quot; data-ke-size=&quot;size16&quot;&gt;P(n, k) = P(n &amp;minus; k, k) + P(n, k &amp;minus; 1)&lt;br /&gt;with P(0, 0) = 1, &amp;nbsp;P(n, 0) = 0 for n &amp;gt; 0 &amp;nbsp; &amp;nbsp; (2)&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;The logic is that partitions of n with maximum part k either use at least one k (in which case, removing one k gives a partition counted by P(n &amp;minus; k, k)) or don&amp;rsquo;t use k at all (giving P(n, k &amp;minus; 1)).&lt;/p&gt;
&lt;h3 id=&quot;actual-code&quot; data-ke-size=&quot;size23&quot;&gt;Actual Code&lt;/h3&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;Based on recurrence relations (2), python code below can calculate P(n):&lt;/p&gt;
&lt;pre class=&quot;python&quot;&gt;&lt;code&gt;&quot;&quot;&quot;
integer partition is a way of writing n as a sum of positive integers.
For example, 4 can be written as:
    4
    = 3 + 1
    = 2 + 2
    = 2 + 1 + 1
    = 1 + 1 + 1 + 1
where the partition number for 4 is 5.
&quot;&quot;&quot;


class Solution:
    &quot;&quot;&quot;Solution for integer partition.&quot;&quot;&quot;

    def __init__(self, _n):
        self._n = _n
        size = self._n + 1
        # cache is n+1 * n+1 matrix
        # where cache[i][j] means P(i, j), the partition number for i with max j.
        self._cache = [[None for _ in range(size)] for _ in range(size)]

    def get_partition(self):
        &quot;&quot;&quot;get partition number for n.&quot;&quot;&quot;
        return self._sub_partition(self._n, self._n)

    def _sub_partition(self, n, k):
        &quot;&quot;&quot;P(n k), sub partition for n with max k.&quot;&quot;&quot;

        # cache hit
        if self._cache[n][k] is not None:
            return self._cache[n][k]

        if k == 0:
            # P(n, 0) = 0 except P(0, 0) = 1
            self._cache[n][k] = 0 if n &amp;gt; 0 else 1
            return self._cache[n][k]

        if n &amp;lt; k:
            # n &amp;lt; k =&amp;gt; P(n, k) = P(n, n)
            self._cache[n][k] = self._sub_partition(n, n)
        else:
            # n &amp;gt;= k =&amp;gt; P(n, k) = P(n-k, k) + P(n, k-1)
            self._cache[n][k] = self._sub_partition(n - k, k) + self._sub_partition(
                n, k - 1
            )
        return self._cache[n][k]


def main():
    &quot;&quot;&quot;main function.&quot;&quot;&quot;
    N = 15
    for target in range(1, N + 1):
        print(f&quot;partition number for {target} is {Solution(target).get_partition()}&quot;)


if __name__ == &quot;__main__&quot;:
    main()&lt;/code&gt;&lt;/pre&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;(개인 호스팅 블로그에서 26.02.10에 작성한 글을 옮겼습니다)&lt;/p&gt;</description>
      <category>수학</category>
      <category>수학</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/65</guid>
      <comments>https://blog.realbro.dev/65#entry65comment</comments>
      <pubDate>Wed, 18 Nov 2026 21:29:28 +0900</pubDate>
    </item>
    <item>
      <title>How TLS Handshake works?</title>
      <link>https://blog.realbro.dev/64</link>
      <description>&lt;h3 id=&quot;symmetric-and-asymmetric-encryption&quot; data-ke-size=&quot;size23&quot;&gt;Symmetric and Asymmetric Encryption&lt;/h3&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;The goal of SSL/TLS is to achieve secure symmetric encryption, while it uses asymmetric encryption during TLS handshake.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&lt;b&gt;The reason why it uses symmetric encryption is performance.&lt;/b&gt; Symmetric encryption (AES) is significantly faster than asymmetric encryption. Asymmetric can only handle small data chunks, while symmetric can efficiently process bulk data. &lt;b&gt;Asymmetric is used only for the handshake to solve the key distribution problem.&lt;/b&gt;&lt;/p&gt;
&lt;p&gt;&lt;figure class=&quot;imageblock alignCenter&quot; data-ke-mobileStyle=&quot;widthOrigin&quot; data-origin-width=&quot;1280&quot; data-origin-height=&quot;731&quot;&gt;&lt;span data-url=&quot;https://blog.kakaocdn.net/dn/ppI43/dJMcaam52Nf/kKcJiqj5Hsh83IcUkGy5l0/img.webp&quot; data-phocus=&quot;https://blog.kakaocdn.net/dn/ppI43/dJMcaam52Nf/kKcJiqj5Hsh83IcUkGy5l0/img.webp&quot;&gt;&lt;img src=&quot;https://blog.kakaocdn.net/dn/ppI43/dJMcaam52Nf/kKcJiqj5Hsh83IcUkGy5l0/img.webp&quot; srcset=&quot;https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&amp;fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FppI43%2FdJMcaam52Nf%2FkKcJiqj5Hsh83IcUkGy5l0%2Fimg.webp&quot; onerror=&quot;this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';&quot; loading=&quot;lazy&quot; width=&quot;1280&quot; height=&quot;731&quot; data-origin-width=&quot;1280&quot; data-origin-height=&quot;731&quot;/&gt;&lt;/span&gt;&lt;/figure&gt;
&lt;/p&gt;
&lt;h3 id=&quot;tls-handshake-steps-with-rsa&quot; data-ke-size=&quot;size23&quot;&gt;TLS Handshake Steps with RSA&lt;/h3&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;TLS handshake happens after TCP handshake, and here is step by step:&lt;/p&gt;
&lt;ol style=&quot;list-style-type: decimal;&quot; data-ke-list-type=&quot;decimal&quot;&gt;
&lt;li&gt;&lt;b&gt;Client Hello&lt;/b&gt;: Client sends supported TLS version, cipher suites, and &amp;ldquo;client random&amp;rdquo; string.&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Server Hello&lt;/b&gt;: Server sends chosen TLS version, cipher suite, and &amp;ldquo;server random&amp;rdquo; string.&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Server Certificate&lt;/b&gt;: Server sends SSL Certificate.&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Certificate Authentication&lt;/b&gt;: Client authenticates server using the SSL certificate.&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Premaster Secret&lt;/b&gt;: Client encrypts premaster secret using public key from SSL certificate and sends it to server.&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Session Key Generation&lt;/b&gt;: Both generate session key using client random, server random, and premaster secret.
&lt;ul style=&quot;list-style-type: disc;&quot; data-ke-list-type=&quot;disc&quot;&gt;
&lt;li&gt;Client has all three values.&lt;/li&gt;
&lt;li&gt;Server has client random and server random, then decrypts premaster secret using certificate&amp;rsquo;s private key.&lt;/li&gt;
&lt;/ul&gt;
&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Client Ready&lt;/b&gt;: Client signals it&amp;rsquo;s ready to begin encrypted communication.&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Server Ready&lt;/b&gt;: Server signals it&amp;rsquo;s ready to begin encrypted communication.&lt;/li&gt;
&lt;li&gt;&lt;b&gt;Secure Symmetric Encryption Achieved&lt;/b&gt;.&lt;/li&gt;
&lt;/ol&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;This describes only the RSA key exchange algorithm for a &amp;ldquo;full handshake&amp;rdquo;. RSA key exchange is not supported in TLSv1.3 and is considered insecure. (TODO: reasons for insecurity)&lt;/p&gt;
&lt;h3 id=&quot;reference&quot; data-ke-size=&quot;size23&quot;&gt;Reference&lt;/h3&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&lt;a href=&quot;https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/&quot;&gt;What happens in a TLS handshake? | SSL handshake | Cloudflare&lt;/a&gt;&amp;nbsp;&lt;/p&gt;
&lt;figure id=&quot;og_1795049882156&quot; contenteditable=&quot;false&quot; data-ke-type=&quot;opengraph&quot; data-ke-align=&quot;alignCenter&quot; data-og-type=&quot;website&quot; data-og-title=&quot;What Happens in a TLS Handshake? | SSL Handshake&quot; data-og-description=&quot;A TLS handshake enables clients and servers to establish a secure connection and create session keys. Learn more about how a TLS vs SSL handshake works.&quot; data-og-host=&quot;www.cloudflare.com&quot; data-og-source-url=&quot;https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/&quot; data-og-url=&quot;https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/&quot; data-og-image=&quot;https://scrap.kakaocdn.net/dn/dPIOz7/dJMb87gzx0J/lDehjXzhVGkPh5L4IegNy0/img.png?width=1400&amp;amp;height=800&amp;amp;face=0_0_1400_800,https://scrap.kakaocdn.net/dn/c1nDMk/dJMb88Gycwi/pLKsGzKqlhG5pkHMdEOpOK/img.png?width=1400&amp;amp;height=800&amp;amp;face=0_0_1400_800,https://scrap.kakaocdn.net/dn/cX0u69/dJMb9aK7ASA/bFKETehTaiUJIxSvBL0jyK/img.png?width=2918&amp;amp;height=1667&amp;amp;face=0_0_2918_1667&quot;&gt;&lt;a href=&quot;https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot; data-source-url=&quot;https://www.cloudflare.com/learning/ssl/what-happens-in-a-tls-handshake/&quot;&gt;
&lt;div class=&quot;og-image&quot; style=&quot;background-image: url('https://scrap.kakaocdn.net/dn/dPIOz7/dJMb87gzx0J/lDehjXzhVGkPh5L4IegNy0/img.png?width=1400&amp;amp;height=800&amp;amp;face=0_0_1400_800,https://scrap.kakaocdn.net/dn/c1nDMk/dJMb88Gycwi/pLKsGzKqlhG5pkHMdEOpOK/img.png?width=1400&amp;amp;height=800&amp;amp;face=0_0_1400_800,https://scrap.kakaocdn.net/dn/cX0u69/dJMb9aK7ASA/bFKETehTaiUJIxSvBL0jyK/img.png?width=2918&amp;amp;height=1667&amp;amp;face=0_0_2918_1667');&quot;&gt;&amp;nbsp;&lt;/div&gt;
&lt;div class=&quot;og-text&quot;&gt;
&lt;p class=&quot;og-title&quot; data-ke-size=&quot;size16&quot;&gt;What Happens in a TLS Handshake? | SSL Handshake&lt;/p&gt;
&lt;p class=&quot;og-desc&quot; data-ke-size=&quot;size16&quot;&gt;A TLS handshake enables clients and servers to establish a secure connection and create session keys. Learn more about how a TLS vs SSL handshake works.&lt;/p&gt;
&lt;p class=&quot;og-host&quot; data-ke-size=&quot;size16&quot;&gt;www.cloudflare.com&lt;/p&gt;
&lt;/div&gt;
&lt;/a&gt;&lt;/figure&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;(개인 호스팅 블로그에서 25.07.24에 작성한 글을 옮겼습니다)&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;</description>
      <category>dev/네트워크</category>
      <category>네트워크</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/64</guid>
      <comments>https://blog.realbro.dev/64#entry64comment</comments>
      <pubDate>Wed, 18 Nov 2026 21:13:00 +0900</pubDate>
    </item>
    <item>
      <title>정보보안기사 합격 후기</title>
      <link>https://blog.realbro.dev/63</link>
      <description>&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p&gt;&lt;figure class=&quot;imageblock alignCenter&quot; data-ke-mobileStyle=&quot;widthOrigin&quot; data-origin-width=&quot;1280&quot; data-origin-height=&quot;773&quot;&gt;&lt;span data-url=&quot;https://blog.kakaocdn.net/dn/chCDOZ/dJMcac6qEwB/Ngv7AAXakkxJWcVpaMNpWk/img.webp&quot; data-phocus=&quot;https://blog.kakaocdn.net/dn/chCDOZ/dJMcac6qEwB/Ngv7AAXakkxJWcVpaMNpWk/img.webp&quot;&gt;&lt;img src=&quot;https://blog.kakaocdn.net/dn/chCDOZ/dJMcac6qEwB/Ngv7AAXakkxJWcVpaMNpWk/img.webp&quot; srcset=&quot;https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&amp;fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FchCDOZ%2FdJMcac6qEwB%2FNgv7AAXakkxJWcVpaMNpWk%2Fimg.webp&quot; onerror=&quot;this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';&quot; loading=&quot;lazy&quot; width=&quot;1280&quot; height=&quot;773&quot; data-origin-width=&quot;1280&quot; data-origin-height=&quot;773&quot;/&gt;&lt;/span&gt;&lt;/figure&gt;
&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;개발자로 일하면서 정보보안을 몰라서 막연한 불안함이 있었다. 카페에서 와이파이를 사용해도 괜찮은지, 혹시나 해킹을 당하지 않을지 등 걱정이 있었고, 자연스럽게 &lt;a href=&quot;https://www.youtube.com/@Normaltic&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;노말틱 유튜브 채널&lt;/a&gt; 등을 보면서 정보보안에 관심을 가졌다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;의미없이 시간을 보내는 것보다 재미로 정보보안 공부를 하면 좋겠다는 생각을 했고, 마침 정보보안기사가 기사 자격증 중 어려운 편이라 하길래 도전했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;도전은 가볍게 했지만 범위가 상당히 넓고 내용이 생각보다 어려워서 공부할게 많았다. 미지의 영역이었던 정보보안에 대한 지식을 얻었고, 개인적으로 부족했던 컴퓨터 시스템/네트워크 부분도 이번 기회에 조금 더 깊이 공부하는 계기가 되어서 좋았다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;정보보안기사 자격증 자체는 사용할 데도 없어 보이고 앞으로 도움이 될 지 모르겠다. 하지만 준비하고 공부하는 과정에서 얻은게 많아서 기분이 좋다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;h3 id=&quot;필기-후기&quot; data-ke-size=&quot;size23&quot;&gt;필기 후기&lt;/h3&gt;
&lt;p&gt;&lt;figure class=&quot;imageblock alignCenter&quot; data-ke-mobileStyle=&quot;widthOrigin&quot; data-origin-width=&quot;1082&quot; data-origin-height=&quot;770&quot;&gt;&lt;span data-url=&quot;https://blog.kakaocdn.net/dn/ZMxYO/dJMcac6qEwy/vZpnAe4m8Afk6dw1Yyg0Z0/img.webp&quot; data-phocus=&quot;https://blog.kakaocdn.net/dn/ZMxYO/dJMcac6qEwy/vZpnAe4m8Afk6dw1Yyg0Z0/img.webp&quot;&gt;&lt;img src=&quot;https://blog.kakaocdn.net/dn/ZMxYO/dJMcac6qEwy/vZpnAe4m8Afk6dw1Yyg0Z0/img.webp&quot; srcset=&quot;https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&amp;fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FZMxYO%2FdJMcac6qEwy%2FvZpnAe4m8Afk6dw1Yyg0Z0%2Fimg.webp&quot; onerror=&quot;this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';&quot; loading=&quot;lazy&quot; width=&quot;1082&quot; height=&quot;770&quot; data-origin-width=&quot;1082&quot; data-origin-height=&quot;770&quot;/&gt;&lt;/span&gt;&lt;/figure&gt;
&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;2025년 4회차 필기에 응시해서 86점으로 합격했다.&lt;/p&gt;
&lt;h4 id=&quot;공부-방법--준비-기간&quot; data-ke-size=&quot;size20&quot;&gt;공부 방법 / 준비 기간&lt;/h4&gt;
&lt;ul style=&quot;list-style-type: disc;&quot; data-ke-list-type=&quot;disc&quot;&gt;
&lt;li&gt;준비 기간 4주&lt;/li&gt;
&lt;li&gt;알기사 필기 교재&lt;/li&gt;
&lt;/ul&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;필기는 객관식이라 정확한 개념을 이해하기보다는 키워드 중심으로 학습했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;특히 알기사 필기 교재의 이론서는 두껍고 처음 보는 내용이 많아 준비 기간 4주 동안 이를 모두 읽고 이해하는 것이 어렵다고 생각해서 생략했고, 대신 세트로 묶여 있던 요약집을 반복해서 읽으며 키워드를 숙지했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;그리고 기출문제 1200제 중 앞부분 절반 600제를 반복하면서 대략적인 개념과 문제 유형을 눈에 익혔다. 뒷부분 600제는 지엽적이고 출제가 되어도 맞힐 자신이 없어서 생략했다. 요약집과 기출문제 600제를 반복하는 것만으로도 4주가 금방 지나갔다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;h3 id=&quot;실기-후기&quot; data-ke-size=&quot;size23&quot;&gt;실기 후기&lt;/h3&gt;
&lt;p&gt;&lt;figure class=&quot;imageblock alignCenter&quot; data-ke-mobileStyle=&quot;widthOrigin&quot; data-origin-width=&quot;1280&quot; data-origin-height=&quot;760&quot;&gt;&lt;span data-url=&quot;https://blog.kakaocdn.net/dn/bBUzoT/dJMcac6qEwz/Dhz48zHtZKKniQGSqNEg31/img.webp&quot; data-phocus=&quot;https://blog.kakaocdn.net/dn/bBUzoT/dJMcac6qEwz/Dhz48zHtZKKniQGSqNEg31/img.webp&quot;&gt;&lt;img src=&quot;https://blog.kakaocdn.net/dn/bBUzoT/dJMcac6qEwz/Dhz48zHtZKKniQGSqNEg31/img.webp&quot; srcset=&quot;https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&amp;fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FbBUzoT%2FdJMcac6qEwz%2FDhz48zHtZKKniQGSqNEg31%2Fimg.webp&quot; onerror=&quot;this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';&quot; loading=&quot;lazy&quot; width=&quot;1280&quot; height=&quot;760&quot; data-origin-width=&quot;1280&quot; data-origin-height=&quot;760&quot;/&gt;&lt;/span&gt;&lt;/figure&gt;
&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;2026년 2회차 실기에 응시해서 97점으로 합격했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;필기 동회차(2025년 4회차)에 접수를 했으나 응시하지 않았다. 당시 회사 업무가 몰린 상태였고 실기 기출문제를 훑어봤을 때 남은 기간동안 준비해서 답안을 작성할 수 없다고 생각했다. 시험 5일 전까지 취소하면 50% 환불 가능한 사실을 늦게 알아서 환불받지 못했다. &lt;a href=&quot;https://www.cq.or.kr/qh_quagm05_001.do&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;환불 안내 참고&lt;/a&gt;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;시간이 흘러 2026년 5월에 여유가 생겨 정보보안기사 필기 면제 기간인 2년이 가기 전에 실기 합격을 해야겠다고 생각했다. 마침 전 회차인 2026년 1회차 실기 합격률이 6%대로 낮은 터라 이번이 기회로 보였다. 다행히 2026년 2회차 실기는 훨씬 쉬웠고 단답형 일부(윈도우 감사 정책)를 제외하고 답을 할 수 있었다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;시험 시간을 최대한 채워서 답안을 다듬었는데, 공부할 때 많이 참고했던 &lt;a href=&quot;https://blog.naver.com/stereok2&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;온계절 정보보안기사 블로그&lt;/a&gt;에서 '시험 시간 3시간을 채우는 것이 다음 시험 준비하는 몇 개월을 아껴준다'고 했기 때문이다.&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;h4 id=&quot;공부-방법--준비-기간-1&quot; data-ke-size=&quot;size20&quot;&gt;공부 방법 / 준비 기간&lt;/h4&gt;
&lt;ul style=&quot;list-style-type: disc;&quot; data-ke-list-type=&quot;disc&quot;&gt;
&lt;li&gt;준비 기간 8주&lt;/li&gt;
&lt;li&gt;알기사 실기 교재 + 기출문제&lt;/li&gt;
&lt;li&gt;&lt;a href=&quot;https://blog.naver.com/stereok2&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;온계절 정보보안기사 블로그&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;개발자로 일하고 있지만 비전공자로서 정보보안 기초가 부족해 실기에 나오는 내용이 대부분 낯설었다. 기출문제 반복을 한다고 해서 서술형에 답을 할 수 있을 것 같지 않았다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;먼저 알기사 이론서를 1회 정독하며 실기에서 어떤 내용을 다루는지 파악했다. 그리고 알기사 기출 1200제 문제와 풀이를 읽으며 어떤 주제가 문제로 나오는지, 답안은 어떤 식으로 작성을 하는지 파악을 했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;그 이후부터는 알기사 이론서를 반복해서 읽으며 원리를 이해하려고 노력했다. 이해가 가지 않던 부분도 반복해서 읽고 검색을 하면서 공부하니 이해가 되었다. 원리 중심으로 공부를 해서 이번 시험에 나온 이메일 보안 SPF, DKIM, DMARC와 같은 문제를 자세하게 서술할 수 있었다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;특히 정보보안 관리/법규 부분은 볼펜으로 반복해서 필기하며 외워서 자신이 있었는데 이번 회차에서 중점적으로 나오지 않아 아쉬웠다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;시험 2~3주 전부터는 대중교통 등 이론서를 볼 수 없는 시간에 &lt;a href=&quot;https://blog.naver.com/stereok2&quot; target=&quot;_blank&quot; rel=&quot;noopener&quot;&gt;온계절 정보보안기사 블로그&lt;/a&gt;의 기출문제 풀이 읽기를 반복했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;다른 합격 후기에서 강의를 들으신 분들이 많은데, 알기사 교재가 많은 범위를 다루고 충분히 이해할 수 있게 서술되어 있어서 교재만으로도 준비할 수 있다고 생각한다.&lt;br /&gt;&lt;br /&gt;&lt;br /&gt;(개인 호스팅 블로그에서 26.09.03에 작성한 글을 옮겼습니다)&lt;/p&gt;</description>
      <category>dev/정보보안</category>
      <category>정보보안</category>
      <category>정보보안기사</category>
      <category>후기</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/63</guid>
      <comments>https://blog.realbro.dev/63#entry63comment</comments>
      <pubDate>Wed, 18 Nov 2026 20:56:00 +0900</pubDate>
    </item>
    <item>
      <title>PINTOS 6주차 file system</title>
      <link>https://blog.realbro.dev/59</link>
      <description>&lt;h3&gt;개요&lt;/h3&gt;
&lt;p&gt;이번 주차에는 file system을 공부했다. 시간이 촉박했다. 목요일부터 화요일로 일주일이 채 안되어 파일시스템 이론 위주로 공부했다. 가상메모리만큼은 아니지만 꽤 흥미로운 주제였다. 우리가 사용하는 파일들이 다양한 메커니즘으로 구현되어있지만 적절한 추상화(abstraction)을 제공해 운영체제가 파일 시스템 각각을 인지하지 않아도 같은 api로 작동하게 만든 점이 인상깊었다. 그리고 파일 시스템이 발전해온 과정을 따라가니 사람들이 어떻게 문제를 해결해왔는지 볼 수 있어서 좋았다.&lt;/p&gt;
&lt;h3&gt;37 하드 디스크 드라이브&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;파일 시스템을 하드 디스크의 동작 원리에 맞추어 개발할 만큼 중요한 저장장치&lt;/li&gt;
&lt;li&gt;모든 드라이브는 읽고 쓸 수 있는 많은 수의 섹터(512 바이트 블럭)로 이루어져 있다&lt;/li&gt;
&lt;li&gt;디스크의 주소 공간: n개의 섹터가 있을 때, 0 ~ n-1 섹터들의 배열&lt;/li&gt;
&lt;li&gt;디스크 드라이브 제조사는 하나의 512바이트 블럭에 대해 쓰기만 원자적으로 보장&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;구조&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;플래터(platter): 원형의 표면에 자기적 성질을 변형하여 데이터를 지속, 회전축에 고정되어 회전함&lt;/li&gt;
&lt;li&gt;트랙(track): 플래터에서 동심원 하나(회전축으로부터 같은 거리에 떨어진 섹터들의 집합)&lt;/li&gt;
&lt;li&gt;디스크 헤드(disk head): 읽기/ 쓰기 동작을 하는 주체&lt;/li&gt;
&lt;li&gt;디스크 암(disk arm): 디스크 헤드를 움직이는 주체&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;I/O 시간&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;전체 시간 = 탐색 시간 + 회전 지연 시간 + 전송 시간&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;탐색 시간: 디스크 암을 타겟 트랙 위에 위치시키는 시간(가속 - 활주 - 감속 - 안정화 단계로 구성)&lt;/li&gt;
&lt;li&gt;회전 지연 시간: 디스크 헤드 아래에 원하는 섹터가 위치하기를 기다리는 시간&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;RAID(Redundant Array of Inexpensive Disk)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;여러 개의 하드 디스크를 하나의 하드 디스크처럼 사용하는 시스템&lt;/li&gt;
&lt;li&gt;성능: 여러 개의 디스크를 병렬로 연결하면 I/O시간이 크게 개선된다&lt;/li&gt;
&lt;li&gt;용량: 더 많은 디스크로 많은 용량을 저장을 할 수 있다&lt;/li&gt;
&lt;li&gt;신뢰성: 분산하여 저장해 하나의 디스크 고장에 대응할 수 있다&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;40 파일 시스템 구현: vsfs(Very Simple File System)&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;파일 시스템은 순수한 소프트웨어: VM/ cpu 가상화와 달리 하드웨어의 도움이 필요하지 않다&lt;/li&gt;
&lt;li&gt;매우 다양한 파일시스템이 있고, 서로 다른 자료구조를 사용한다&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;자료구조: 파일 시스템이 자신의 데이터와 메타 데이터를 관리하기 위해 디스크 상에 어떤 자료 구조가 있어야 하는가?&lt;/li&gt;
&lt;li&gt;접근방법: 프로세스가 open(), read(), write() 등의 시스템 콜을 호출할 때, 어떤 자료구조가 읽히고 어떤 것들이 쓰이는지, 얼마나 효율적으로 동작하는지?&lt;/li&gt;
&lt;li&gt;자료구조, 접근방법 이해 후 실제 동작 방식에 대한 개념 모델 정립 &amp;lt;-- 시스템적 사고 방식의 핵심&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;vsfs 구성&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;디스크를 블럭(512 바이트)으로 나눈 뒤 다음의 영역들로 구분한다 &lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;슈퍼블럭: 파일시스템 전체에 대한 정보(아이노드 블럭 개수, 데이터 블럭 개수, 아이노드 테이블이 어디서 시작하는지 등)&lt;/li&gt;
&lt;li&gt;아이노드 비트맵: 아이노드 테이블에 있는 아이노드 사용 여부&lt;/li&gt;
&lt;li&gt;데이터 비트맵: 데이터 블럭들의 사용 여부&lt;/li&gt;
&lt;li&gt;아이노드 테이블: 아이노드의 저장 공간&lt;/li&gt;
&lt;li&gt;데이터 영역: 사용자 데이터가 있는 디스크 공간&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;아이노드&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;파일의 저수준 이름(low-level name)&lt;/li&gt;
&lt;li&gt;파일의 메타 데이터를 저장하기위한 자료구조로서, 파일 시스템의 디스크 자료구조 중 가장 중요&lt;/li&gt;
&lt;li&gt;파일 종류(일반 파일, 디렉토리), 할당 블럭 수, 시간 정보, 파일 크기, 접근 권한, 파일 블럭들의 위치 정보 저장&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;멀티 레벨 인덱스&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;큰 파일을 지원하기 위해 사용&lt;/li&gt;
&lt;li&gt;간접 포인터 사용: 간접 포인터가 가리키는 블럭에는 데이터 블럭을 가리키는 포인터들이 저장&lt;/li&gt;
&lt;li&gt;이중 간접 포인터, 삼중 간접 포인터 등 사용&lt;/li&gt;
&lt;li&gt;대부분의 파일 크기는 작으므로 작은 파일을 빨리 읽고 쓸 수 있는 파일 구조&lt;/li&gt;
&lt;li&gt;파일 시스템 소프트웨어는 손쉽게 변경이 가능&lt;/li&gt;
&lt;li&gt;워크로드 특성의 변화에 따라, 새로운 파일 구성을 연구 개발할 자세가 되어 있어야 함&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;디렉터리 구조&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;(항목 이름, 아이노드 번호) 쌍의 배열로 구성&lt;/li&gt;
&lt;li&gt;&amp;quot;.&amp;quot;는 현재 디렉터리, &amp;quot;..&amp;quot;는 부모 디렉터리&lt;/li&gt;
&lt;li&gt;디렉터리는 특수한 종류의 파일로 간주, 자신의 아이노드를 가지고, 이 아이노드는 아이노드 테이블에 존재&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;a href=&quot;https://velog.io/@tpclsrn7942/%EC%A0%80%EB%84%90%EB%A7%81&quot;&gt;세친구7942님 파일 읽기/ 쓰기 참고&lt;/a&gt;&lt;/p&gt;
&lt;h4&gt;실행 흐름: 파일 읽기&lt;/h4&gt;
&lt;p&gt;&amp;quot;/foo/bar&amp;quot;를 읽는 과정을 예로 들어보자&lt;br&gt;&lt;figure class=&quot;imageblock alignCenter&quot; width=&quot;100%&quot;&gt;&lt;span data-url=&quot;https://blog.kakaocdn.net/dn/cWbRLy/btrjIzJHttT/ZwGZduZ77Kk4CEzQ0qYnhK/img.png&quot; data-phocus=&quot;https://blog.kakaocdn.net/dn/cWbRLy/btrjIzJHttT/ZwGZduZ77Kk4CEzQ0qYnhK/img.png&quot;&gt;&lt;img src=&quot;https://blog.kakaocdn.net/dn/cWbRLy/btrjIzJHttT/ZwGZduZ77Kk4CEzQ0qYnhK/img.png&quot; srcset=&quot;https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&amp;amp;fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FcWbRLy%2FbtrjIzJHttT%2FZwGZduZ77Kk4CEzQ0qYnhK%2Fimg.png&quot; width=&quot;100%&quot; onerror=&quot;this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';&quot;/&gt;&lt;/span&gt;&lt;/figure&gt;
&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;open(bar)&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;&amp;quot;/&amp;quot;(루트) 아이노드에서 루트 디렉토리가 저장된 위치(데이터 블록) 파악(루트 아이노드는 보통 2번)&lt;/li&gt;
&lt;li&gt;루트 디럭터리에서 (&amp;quot;foo&amp;quot;, inodenum_of_foo)를 찾고 &amp;quot;foo&amp;quot;의 아이노드로 이동&lt;/li&gt;
&lt;li&gt;&amp;quot;foo&amp;quot;의 아이노드에서 &amp;quot;foo&amp;quot;의 데이터 블록으로 이동&lt;/li&gt;
&lt;li&gt;&amp;quot;foo&amp;quot;의 디렉터리 데이터에서 (&amp;quot;bar&amp;quot;, inodenum_of_bar)쌍을 찾아 &amp;quot;bar&amp;quot;의 아이노드로 이동&lt;/li&gt;
&lt;li&gt;&amp;quot;bar&amp;quot;의 아이노드를 읽으면 &amp;quot;/foo/bar&amp;quot;를 open()할 수 있음&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;read()&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;6&quot;&gt;
&lt;li&gt;&amp;quot;bar&amp;quot; 파일을 open했으므로 읽기 수행 가능: &amp;quot;bar&amp;quot;의 아이노드를 읽어 &amp;quot;bar&amp;quot; 데이터 블록으로 이동&lt;/li&gt;
&lt;li&gt;&amp;quot;bar&amp;quot;의 데이터 읽기&lt;/li&gt;
&lt;li&gt;&amp;quot;bar&amp;quot;에 접근했으므로 최종 접근 시간을 &amp;quot;bar&amp;quot;의 아이노드에 기록(write)&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;실행 흐름: 파일 생성&lt;/h4&gt;
&lt;p&gt;&amp;quot;/foo/bar&amp;quot;를 생성하는 과정을 예로 들어보자&lt;br&gt;&lt;figure class=&quot;imageblock alignCenter&quot; width=&quot;100%&quot;&gt;&lt;span data-url=&quot;https://blog.kakaocdn.net/dn/d0rprJ/btrjJqrYZkl/0BaLqgyAOEkP3uP2zzaCBK/img.png&quot; data-phocus=&quot;https://blog.kakaocdn.net/dn/d0rprJ/btrjJqrYZkl/0BaLqgyAOEkP3uP2zzaCBK/img.png&quot;&gt;&lt;img src=&quot;https://blog.kakaocdn.net/dn/d0rprJ/btrjJqrYZkl/0BaLqgyAOEkP3uP2zzaCBK/img.png&quot; srcset=&quot;https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&amp;amp;fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2Fd0rprJ%2FbtrjJqrYZkl%2F0BaLqgyAOEkP3uP2zzaCBK%2Fimg.png&quot; width=&quot;100%&quot; onerror=&quot;this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';&quot;/&gt;&lt;/span&gt;&lt;/figure&gt;
&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;create(/foo/bar)&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;root 아이노드에서 root 데이터 블록 위치 찾고 이동&lt;/li&gt;
&lt;li&gt;root 디렉토리의 데이터에서 (&amp;quot;foo&amp;quot;, inodenum_of_foo)를 찾고 해당 아이노드로 이동&lt;/li&gt;
&lt;li&gt;foo 디렉터리의 아이노드에서 foo 디렉터리의 데이터 블록 위치 찾고 이동&lt;/li&gt;
&lt;li&gt;foo 디렉터리에 파일 bar를 생성하기 위해, 권한 확인 --&amp;gt; 쓰기 권한이 있고, bar라는 파일이 없으면 새 파일을 위한 아이노드를 배정하기 위해 아이노드 비트맵으로 이동&lt;/li&gt;
&lt;li&gt;아이노드 비트맵을 읽어 사용 가능한 아이노드 번호 찾기&lt;/li&gt;
&lt;li&gt;아이노드 비트맵에서 해당 아이노드 번호 사용중으로 표시&lt;/li&gt;
&lt;li&gt;foo 디렉터리의 데이터 블록으로 돌아와 (&amp;quot;bar&amp;quot;, inodenum_of_bar) 추가&lt;/li&gt;
&lt;li&gt;새로 배정한 bar 아이노드 읽고(default 값)&lt;/li&gt;
&lt;li&gt;bar 아이노드에 메타데이터 쓰기&lt;/li&gt;
&lt;li&gt;bar라는 파일이 생성되어 foo가 수정되었으므로, foo의 아이노드 갱신&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;write()&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;11&quot;&gt;
&lt;li&gt;bar 아이노드를 읽고 새로운 데이터를 위한 디스크 블록을 할당하기 위해 데이터 비트맵으로 이동&lt;/li&gt;
&lt;li&gt;데이터 비트맵을 읽고 사용 가능한 디스크 블록 찾기&lt;/li&gt;
&lt;li&gt;데이터 비트맵에서 해당 디스크 블록 사용중으로 표시&lt;/li&gt;
&lt;li&gt;할당 받은 디스크 블록으로 가서 데이터 쓰기&lt;/li&gt;
&lt;li&gt;작업이 끝나면 bar 아이노드로 돌아와 수정된 정보 갱신&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;캐싱과 버퍼링&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;파일을 읽고 쓰는 것은 많은 I/O 발생 --&amp;gt; 자주 사용되는 블럭을 메모리에 캐싱&lt;/li&gt;
&lt;li&gt;쓰기 캐시: 쓰기 시점을 연기(쓰기 버퍼링, write buffering)&lt;/li&gt;
&lt;li&gt;적은 수의 I/O로 일괄 처리(batch)&lt;/li&gt;
&lt;li&gt;쓰기 자체를 피할 수 있다: 파일 생성 후 즉시 삭제하는 경우, 컴파일 과정에서 생기는 임시 파일 등&lt;/li&gt;
&lt;li&gt;fsync(): 쓰기 버퍼링으로 인한 예기치 않은 데이터 유실 방지, 호출시 갱신된 내용을 디스크에 강제적으로 기록&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;41 지역성과 FFS(Fast File System)&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;문제1: 기존 파일 시스템은 디스크를 마치 RAM처럼 사용하여 디스크 헤드를 이동시키는데 많은 시간 소요&lt;/li&gt;
&lt;li&gt;문제2: 디스크의 빈 공간을 효율적으로 관리하지 않아 단편화(fragmentation) 발생&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;디스크에 대한 이해&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;파일 시스템의 자료 구조와 할당 정책을 &amp;quot;디스크에 적합&amp;quot;하게 설계&lt;/li&gt;
&lt;li&gt;파일 시스템의 인터페이스는 그대로 유지: open(), read(), write(), close()&lt;/li&gt;
&lt;li&gt;내부 구현 방식 변경&lt;/li&gt;
&lt;li&gt;거의 모든 현대의 파일 시스템은 기존의 인터페이스를 그대로 사용하면서 성능과 신뢰성 또는 기타 다른 목적으로 내부를 최적화한다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;실린더 그룹&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;디스크를 여러 개의 실린더 그룹(cylinder group)으로 분할&lt;/li&gt;
&lt;li&gt;각 그룹별로 아이노드 비트맵과 데이터 비트맵을 두어 관리&lt;/li&gt;
&lt;li&gt;아이노드와 파일의 데이터 블록을 같은 그룹에 할당하여 아이노드와 데이터 간의 긴 탐색 방지&lt;/li&gt;
&lt;li&gt;FFS는 파일과 그 파일이 속한 티렉터리 블록을 같은 그룹에 할당&lt;/li&gt;
&lt;li&gt;긴 파일 이름 지원&lt;/li&gt;
&lt;li&gt;심볼릭 링크 개념 도입&lt;/li&gt;
&lt;li&gt;FFS 이후, 파일 시스템 연구 증가 &lt;/li&gt;
&lt;/ul&gt;</description>
      <category>dev/SW정글</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/59</guid>
      <comments>https://blog.realbro.dev/59#entry59comment</comments>
      <pubDate>Tue, 2 Nov 2021 16:27:27 +0900</pubDate>
    </item>
    <item>
      <title>PINTOS 4-5주차 VM</title>
      <link>https://blog.realbro.dev/58</link>
      <description>&lt;h3&gt;개요&lt;/h3&gt;
&lt;p&gt;이번 주차에서는 가상메모리(Virtual Memory)에 대해 다루었다. 이 문서에는 operating system: three easy pieces의 VM 내용을 대략적으로 살펴보려 한다.&lt;/p&gt;
&lt;h3&gt;메로리 가상화란&lt;/h3&gt;
&lt;p&gt;운영체제가 각 프로세스마다 자신만의 커다란 전용 메모리를 가진다는 환상을 제공하는 것&lt;/p&gt;
&lt;h3&gt;13 주소 공간의 개념&lt;/h3&gt;
&lt;h4&gt;13.1 초기 시스템&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;초기 컴퓨터에서, 운영체제는 메모리에 상주하는 라이브러리의 집합이었을 뿐이다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;13.2 멀티프로그래밍과 시분할&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;멀티 프로그래밍(multi-programming)의 시대가 되어 컴퓨터를 공유하기 시작했다&lt;/li&gt;
&lt;li&gt;프로세스 전환을 통해 CPU의 이용률, 효율성을 개선했다.&lt;/li&gt;
&lt;li&gt;시분할(time-sharing)의 시대, interactivity의 중요성 부각&lt;/li&gt;
&lt;li&gt;여러 프로그램이 메모리에 동시에 존재하면서 보호(protection)가 중요한 문제로 부각&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;13.3 주소 공간&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;사용하기 쉬운 메모리 개념&lt;/li&gt;
&lt;li&gt;주소공간은 실행 프로그램의 모든 메모리 상태를 가짐&lt;/li&gt;
&lt;li&gt;코드, 스택(함수 호출 지역변수, 인자, 반환 값 등), 힙(동적 할당) 등&lt;/li&gt;
&lt;li&gt;실제로는 변환되어 임의의 물리 주소(physical address)에 탑재&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;13.4 VM의 목표&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;투명성(transparency): 실행 중인 프로세스가 가상 메모리의 존재를 인지하지 못하도록 해야 함(오히려 자신의 전용 물리 메모리를 소유한 것처럼 행동해야 함)&lt;/li&gt;
&lt;li&gt;효율성(efficiency): 시간, 공간적으로 효율적으로 작동해야 함(멀티 레벨, TLB 등을 통해 구현)&lt;/li&gt;
&lt;li&gt;보호(protection): 자신의 주소 공간 밖에 접근할 수 없다&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;볼 수 있는 모든 주소는 가상 주소이다&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;C 프로그램에서 포인터로 출력할 수 있는 주소는 모두 가상 주소이다&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;14 메모리 관리 API&lt;/h3&gt;
&lt;h4&gt;14.1 메모리 공간의 종류&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;스택: 컴파일러에 의해 할당, 반환이 암묵적으로 이루어지는 자동(automatic) 메모리&lt;/li&gt;
&lt;li&gt;힙: 할당과 반환이 프로그래며에 의해 명시적으로 처리된다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;14.4 흔한 오류&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;메모리 할당 잊어버리기&lt;/li&gt;
&lt;li&gt;메모리 부족하게 할당받기: 버퍼 오버플로우(buffer overflow)&lt;/li&gt;
&lt;li&gt;할당받은 메모리 초기화하지 않기&lt;/li&gt;
&lt;li&gt;메모리 해제하지 않기: 메모리 누수(memory leak)&lt;/li&gt;
&lt;li&gt;메모리 사용이 끝나기 전에 메모리 해제하기&lt;/li&gt;
&lt;li&gt;반복적으로 메모리 해제하기&lt;/li&gt;
&lt;li&gt;free() 잘못 호출하기&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;15 주소 변환의 원리&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;효율성: 하드웨어 지원 활용&lt;/li&gt;
&lt;li&gt;제어: 응용 프로그램이 자기 자신의 메모리 이외의 다른 메모리에 접근하지 못하는 것을 운영체제가 보장&lt;/li&gt;
&lt;li&gt;유연성: 프로그래머가 원하는 대로 주소 공간을 사용하고, 프로그래밍하기 쉬운 시스템&lt;/li&gt;
&lt;li&gt;주소 변환(address translation): 가상주소를 실제 존재하는 물리 주소로 변환&lt;/li&gt;
&lt;li&gt;목표: 프로그램이 자신의 전용 메모리를 소유하고 그 안에 자신의 코드와 데이터가 있다는 환상을 만드는 것&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;15.3 동적 재배치(베이스와 바운드)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;2개의 레지스터: 베이스(base) 레지스터, 바운드(bound) 레지스터&lt;/li&gt;
&lt;li&gt;PA(physical address) = VA(virtual address) + base&lt;/li&gt;
&lt;li&gt;바운드 레지스터는 보호(protection)를 지원하기 위해 존재&lt;/li&gt;
&lt;li&gt;베이스, 바운드 레지스터는 CPU 칩상에 존재하는 하드웨어(MMU, memory management unit)의 일부&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;동적 재배치를 위한 하드웨어 요구사항&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;특권모드: 사용자 모드 프로세스가 특권 연산을 실행하는 것을 방지하기 위해 필요&lt;/li&gt;
&lt;li&gt;베이스/ 바운드 레지스터: 주소 변환과 범위 검사를 지원&lt;/li&gt;
&lt;li&gt;가상주소 변환, 범위 내 검사: 간단한 회로를 통해 지원&lt;/li&gt;
&lt;li&gt;베이스/ 바운드 갱신을 위한 특권 명령어: 프로그램 시작 전 운영체제가 베이스, 바운드 레지스터 값을 지정할 수 있어야 함&lt;/li&gt;
&lt;li&gt;예외 핸들러 등록을 위한 특권 명령어: 운영체제가 예외 처리 코드를 하드웨어에게 알려줄 수 있어야 함&lt;/li&gt;
&lt;li&gt;예외 발생 기능: 프로세스가 특권 명령어 실행을 시도하거나 범위를 벗어난 메모리의 접근을 시도할 때 예외를 발생시킬 수 있어야 함&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;15.5 운영체제 이슈&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;프로세스 생성시, 운영체제는 주소 공간이 저장될 메모리 공간을 찾아 조치를 취해야 한다(free-list 등)&lt;/li&gt;
&lt;li&gt;프로세스 종료시, 프로세스가 사용하던 메모리를 회수해 다른 프로세스 혹은 운영체제가 재사용할 수 있어야 한다&lt;/li&gt;
&lt;li&gt;문맥교환(context switch)시 베이스, 바운드 쌍을 저장하고 복원해야 한다(PCB: process control block)&lt;/li&gt;
&lt;li&gt;예외 핸들러 제공: 운영체제는 부팅할 때 특권 명령어를 사용하여 예외 핸들러를 설치한다&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;16 세그멘테이션&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;베이스/ 바운드 방식은 메모리 낭비가 심하다(스택과 힙 사이의 사용하지 않는 공간)&lt;/li&gt;
&lt;li&gt;주소 공간이 물리 메모리보다 큰 경우 실행 어렵다&lt;/li&gt;
&lt;li&gt;유연성이 없다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;16.1 세그멘테이션: 베이스/바운드(base/ bound)의 일반화&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;MMU 안에 오직 한 쌍의 베이스/ 바운드 레지스터가 있는 것이 아니라 주소 공간의 논리적인 세그먼트마다 베이스/ 바운드 쌍이 존재한다&lt;/li&gt;
&lt;li&gt;각 논리 세그먼터(코드, 힙, 스택)마다의 오프셋을 통해 위치 파악&lt;/li&gt;
&lt;li&gt;세그먼트 폴트(segment fault): 하드웨어가 주소 범위를 벗어났다는 것을 감지하고 운영체제에 트랩 발생&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;16.2 세그먼트 종류의 파악&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;가상 주소 최상위 2 bit 혹은 1 bit를 세그먼트 구분을 위해 할당&lt;/li&gt;
&lt;li&gt;가상 주소의 나머지 bit를 해당 세그먼트에서의 offset으로 활용&lt;/li&gt;
&lt;li&gt;혹은 묵시적(implicit) 접근방식: 주소가 어떻게 형성되었는지를 관찰하여 세그먼트를 결정&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;16.3 스택&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;스택은 다른 세그먼트와 달리 반대 방향으로 확장&lt;/li&gt;
&lt;li&gt;간단한 하드웨어가 추가로 필요: 1 bit 할당하여 음의 방향으로 확장한다는 정보 표시&lt;/li&gt;
&lt;li&gt;offset도 다른 방식으로 얻는다: 보수(complement) 계산 방식이랑 비슷하다&lt;/li&gt;
&lt;li&gt;(기존 오프셋 - 최대 세그먼트 크기)로 음(-)의 오프셋을 얻는다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;16.4 공유 지원&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;protection bit를 통해 주소 공간들 간에 특정 메모리 세그먼트를 공유하는 것이 가능하다&lt;/li&gt;
&lt;li&gt;코드 세그먼트를 읽기 전용으로 설정하여 주소 공간의 독립성을 유지하면서, 여러 프로세스가 주소 공간의 일부를 공유할 수 있다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;16.5 운영체제의 지원&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;문맥교환(context switch)시 세그먼트 레지스터의 저장과 복원&lt;/li&gt;
&lt;li&gt;미사용 중이 물리 메모리 공간의 관리: free-list&lt;/li&gt;
&lt;li&gt;외부 단편화(external fragmentation): 물리 메모리 압축(compact), free-list관리 기법(best-fit, worst-fit, first-fit 등)&lt;/li&gt;
&lt;li&gt;좋은 알고리즘은 외부 단편화를 가능한 줄이는 것이 목표이다&lt;/li&gt;
&lt;li&gt;외부 단편화를 해결하는 &amp;quot;최선&amp;quot;의 해결책은 존재하지 않는다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;세그먼트 문제&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;세그먼트 크기가 일정하지 않기 때문에 외부 단편화 발생(불가피함)&lt;/li&gt;
&lt;li&gt;유연하지 못함&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;17 빈 공간 관리&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;메모리 가상화 뿐만 아니라 메모리 관리 시스템의 근본적인 측면&lt;/li&gt;
&lt;li&gt;malloc 라이브러리, 프로세스 주소 공간, 운영체제 자체 등 빈 공간의 관리&lt;/li&gt;
&lt;li&gt;고정 크기단위로 나뉜 경우(페이징) 빈 공간 관리는 쉽다&lt;/li&gt;
&lt;li&gt;가변 크기의 빈 공간들의 집합일 경우 외부 단편화 발생&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;17.2 저수준 기법: 분할과 병합&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;분할: 비교적 큰 빈 공간에 할당할 경우 할당 공간/ 남는 빈 공간으로 분할하여 &amp;quot;남는 빈 공간&amp;quot;을 새로 빈 공간 리스트에 추가한다&lt;/li&gt;
&lt;li&gt;병합: 새로 해제된 메모리 청크의 인접 청크가 빈 공간이라면 그들을 합쳐 하나의 큰 메모리 청크로 만들어 관리한다&lt;/li&gt;
&lt;li&gt;할당된 공간 크기의 파악: 추가 정보(meta-data)를 헤더 블록에 저장&lt;/li&gt;
&lt;li&gt;사실 빈 영역의 크기는 &amp;quot;헤더 크기 + 사용자에게 할당된 영역의 크기&amp;quot;이다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;기본 전략들&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;속도가 빠르고 단편화를 최소로 해야 한다&lt;/li&gt;
&lt;li&gt;어떠한 전략도 잘 맞지 않는 입력(메모리 할당 패턴)을 만나면 성능이 매우 좋지 않을 수 있다&lt;/li&gt;
&lt;li&gt;최선은 없다, 장단점이 있을 뿐이다&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;최적 적합(best fit)&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;후보자 그룹(할당 가능한 빈 공간들)에서 가장 작은 크기의 청크를 할당&lt;/li&gt;
&lt;li&gt;사용자가 요청한 크기에 가까운 블럭을 반환함으로써 공간의 낭비를 줄이려고 노력&lt;/li&gt;
&lt;li&gt;성능 저하(높은 비용): 항상 전체를 검색&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;2&quot;&gt;
&lt;li&gt;최악 적합(worst fit)&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;후보자 그룹에서 가장 큰 청크에 할당&lt;/li&gt;
&lt;li&gt;많은 작은 청크를 남기는 대신 커다란 빈 청크를 남기려고 시다&lt;/li&gt;
&lt;li&gt;성능 저하(높은 비용): 항상 전체를 검색&lt;/li&gt;
&lt;li&gt;엄청난 단편화 발생&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;3&quot;&gt;
&lt;li&gt;최초 적합(first fit)&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;요청보다 큰 첫 번째 빈 블록 할당&lt;/li&gt;
&lt;li&gt;속도가 빠르다&lt;/li&gt;
&lt;li&gt;리스트의 시작 부분(앞부분)에 크기가 작은 객체가 많이 생길 수 있다&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;4&quot;&gt;
&lt;li&gt;다음 적합(next fit)&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;최초적합과 같으나 탐색 시작이 마지막으로 찾았던 원소 다음&lt;/li&gt;
&lt;li&gt;리스트의 첫부분에만 단편이 집중적으로 발생하는 현상 방지&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;5&quot;&gt;
&lt;li&gt;개별 리스트(segregated list)&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;크기별로 리스트 운용&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;6&quot;&gt;
&lt;li&gt;슬랩 할당기(slab allocator)&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;18 페이징&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;세그멘테이션(가변 크기 분할)은 단편화 발생&lt;/li&gt;
&lt;li&gt;페이징은 공간을 동일 크기의 조각으로 분할&lt;/li&gt;
&lt;li&gt;물리 메모리도 페이지 프레임(page frame)으로 불리는 고정 크기의 슬롯의 배열이라고 간주한다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;페이징 개요&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;유연성: 프로세스의 주소 공간 사용 방식(힙, 스택)과 상관 없이 효율적으로 주소 공간 개념 지원&lt;/li&gt;
&lt;li&gt;빈 공간 관리의 단순함: 모든 비어있는 페이지의 빈 공간 리스트를 관리하고 비어있는 n개의 칸을 찾으면 된다&lt;/li&gt;
&lt;li&gt;운영체제는 프로세스마다 페이지 테이블(page table)이라는 자료구조 유지(## 페이지 테이블은 프로세스마다 존재한다 ##)&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;주소 변환 (VA to PA)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;&lt;p&gt;가상 주소를 두 부분으로 나눔: VA(virtual address) = VPN(virtual page number) + OFS(offset)&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;VPN: 해당 페이지의 번호(페이지 테이블에서 몇 번째 페이지인지)&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;OFS: 그 페이지에서 몇 번째에 해당하는 위치&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;ex) 32bit주소체계: VA = |&amp;lt;--- VPN 20 bit ---&amp;gt;|&amp;lt;--- OFS 12 bit ---&amp;gt;|&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;주소 변환을 통해 VPN을 PFN으로 변환하고 실제 물리 주소를 만든다: PA(physical address) = PFN(physical frame number) + OFS&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;PFN: 해당 물리 프레임의 번호(실제 물리 메모리에서 몇 번째 프레임인지)&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;OFS는 동일하다: 해당 프레임에서 해당하는 위치는 (가상 페이지 내부에서의 위치와) 같다&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;&lt;p&gt;ex) PA = |&amp;lt;--- PFN n bit ---&amp;gt;|&amp;lt;--- OFS 12 bit ---&amp;gt;|&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;페이지 테이블&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;가상주소의 VPN을 물리 주소의 PFN으로 매핑하는 자료구조&lt;/li&gt;
&lt;li&gt;페이지 테이블은 메모리에 위치하나, 트리 구조로 단계를 높일 경우 디스크에 스왑될 수 있다(중요한 첫 부분은 메모리 상주)&lt;/li&gt;
&lt;li&gt;선형 자료구조 이외에도 트리 등 고급 자료구조 활용&lt;/li&gt;
&lt;li&gt;각 PTE(page table entry)에는 VPN에 해당하는 PFN 이외에도 valid bit, protection bit, dirty bit, reference bit, 읽기/쓰기 비트, 사용자/관리자 비트로 각 페이지에 대한 추가 정보를 전한다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;페이징 단점&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;느리다: 물리 주소를 알기 위해 페이지 테이블에 접근해야 함(메모리에 2번 접근) --&amp;gt; TLB(하드웨어) 도입&lt;/li&gt;
&lt;li&gt;메모리 낭비: PTE가 많을 경우 페이지 테이블을 위해 많은 메모리를 할당해야 함 --&amp;gt; 멀티 레벨 페이지 테이블 도입&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;19 TLB(translation lookaside buffer)&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;주소 변환을 위해 페이지 테이블에 접근하려면 메모리에 한번 이상 접근해야 한다 --&amp;gt; 느리다!!&lt;/li&gt;
&lt;li&gt;하드웨어의 도움을 통해 실행 속도를 향상: TLB&lt;/li&gt;
&lt;li&gt;TLB: 자주 참조되는 &amp;quot;가상주소 - 실제 주소&amp;quot;의 변환 정보를 저장하는 하드웨어 캐시&lt;/li&gt;
&lt;li&gt;가상메모리 참조 시, 페이지 테이블(메모리)을 참조하기 전 TLB(빠른 캐시)에 정보가 있는지 먼저 확인&lt;/li&gt;
&lt;li&gt;지역성 활용&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;시간 지역성(temporal locality): 최근에 접근된 명령어 또는 데이터는 곧 다시 접근될 확률이 높다(반복문)&lt;/li&gt;
&lt;li&gt;공간 지역성(spatial locality): 참조된 데이터에 인접한 데이터에 접근될 확률이 높다(배열)&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;가상 주소 참조 순서&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;가상 주소에서 VPN 추출하여 TLB에 존재하는지 검사 --&amp;gt; TLB 히트 --&amp;gt; 물리 주소 획득&lt;/li&gt;
&lt;li&gt;TLB 미스의 경우, 페이지 테이블 접근&lt;/li&gt;
&lt;li&gt;가상메모리 참조가 유효하고 접근 가능한 경우 해당 정보를 TLB에 갱신&lt;/li&gt;
&lt;li&gt;가상 주소 참조 재실행 --&amp;gt; TLB 히트&lt;/li&gt;
&lt;/ol&gt;
&lt;h4&gt;TLB 미스의 처리&lt;/h4&gt;
&lt;ol&gt;
&lt;li&gt;하드웨어의 관리&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;CISC(complex instruction set computers)&lt;/li&gt;
&lt;li&gt;하드웨어 관리 TLB&lt;/li&gt;
&lt;/ul&gt;
&lt;ol start=&quot;2&quot;&gt;
&lt;li&gt;소프트웨어(운영체제) 관리:&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;RISC(reduced instruction set computing)&lt;/li&gt;
&lt;li&gt;예외 시그널 박생, 커널모드 변경, 트랩 핸들러&lt;/li&gt;
&lt;li&gt;유연성: 하드웨어 변경 없이 페이지 테이블 구조 변경 가능&lt;/li&gt;
&lt;li&gt;단순함: 하드웨어가 할 일이 별로 없음, TLB 미스 핸들러가 처리함&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;TLB valid bit != 페이지 테이블 vaild bit&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;TLB valid bit: TLB에 탑재된 정보가 유효한지&lt;/li&gt;
&lt;li&gt;PT valid bit: 해당 페이지가 프로세스에 할당되었는지 여부&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;TLB의 문제: 문맥 교환(context switch)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;문맥교환시, 기존 TLB 내용 지우기: TLB valid bit = 0&lt;/li&gt;
&lt;li&gt;교체 정책: LRU(least-recently-used), 랜덤&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;20 더 작은 테이블&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;페이지 테이블 엔트리(PTE)가 많아지면 페이지 테이블 자체의 크기가 커져, 메모리를 많이 차지한다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;20.1 해법1: 더 큰 페이지&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;페이지를 크게 하면 VPN bit가 줄어들어 PTE가 감소한다&lt;/li&gt;
&lt;li&gt;다만 페이지 크기가 커지면 페이지 내부의 낭비 공간이 증가할 수 있다(내부 단편화: internal fragmentation)&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;20.2 하이브리드: 페이징과 세그먼트&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;논리 세그먼트마다 페이지 테이블을 따로 둔다&lt;/li&gt;
&lt;li&gt;세그먼트마다 베이스/ 바운드 레지스터를 따로 둔다&lt;/li&gt;
&lt;li&gt;세그먼테이션을 사용하기 때문에 유연하지 못함&lt;/li&gt;
&lt;li&gt;외부 단편화&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;20.3 멀티 레벨 페이지 테이블&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;선형 페이지 테이블을 트리 구조로 표현&lt;/li&gt;
&lt;li&gt;페이지 테이블을 페이지 크기로 나눈다&lt;/li&gt;
&lt;li&gt;페이지 디렉토리(page directory)를 두어 각 엔트리마다 나뉘어진 페이지 테이블의 할당 여부와 위치를 파악한다&lt;/li&gt;
&lt;li&gt;장점1: 사용된 주소공간에 비례해서 페이지 테이블 공간이 할당 --&amp;gt; 적은 크기의 페이지 테이블로 주소 공간 표현 가능&lt;/li&gt;
&lt;li&gt;장점2: 페이지 테이블을 페이지 크기로 분할하여 메모리 관리가 용이함(페이지 테이블을 할당하거나 확장할 때, 빈 페이지를 가져다 쓰면 된다)&lt;/li&gt;
&lt;li&gt;단점1: 추가 비용 발생(TLB 미스시, 주소 변환을 위해 2번 이상의 메모리 로드 발생)&lt;/li&gt;
&lt;li&gt;단점2: 복잡도&lt;/li&gt;
&lt;li&gt;변환 과정&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;VPN 추출하여 TLB에 존재하는지 확인 --&amp;gt; TLB 히트&lt;/li&gt;
&lt;li&gt;TLB 미스시, VPN에서 페이지 디렉토리 항목 추출 --&amp;gt; 페이지 테이블 참조&lt;/li&gt;
&lt;li&gt;페이지 테이블에서 PTE(페이지 테이블 엔트리) 추출 --&amp;gt; TLB에 추가&lt;/li&gt;
&lt;li&gt;다시 시도 --&amp;gt; TLB 히트&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;21 물리 메모리 크기의 극복: 메커니즘(mechanism)&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;큰 주소 공간을 지원하기 위해 운영체제는 주소 공간 중에 현재는 크게 필요하지 않은 일부를 보관해 둘 공간이 필요하다&lt;/li&gt;
&lt;li&gt;스왑 공간이 추가되면 운영체제는 실행되는 각 프로세스들에게 큰 가상 메모리가 있는 것 같은 환상을 줄 수 있다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;21.1 스왑 공간&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;스왑공간: 디스크에 페이지들을 저장할 공간&lt;/li&gt;
&lt;li&gt;swap out: 메모리 페이지를 읽어서 스왑 공간에 쓴다&lt;/li&gt;
&lt;li&gt;swap in: 스왑 공간에서 페이지를 읽어 메모리에 탑재&lt;/li&gt;
&lt;li&gt;운영체제는 스왑 공간에 있는 모든 페이지들의 디스크 주소를 기억해야 한다&lt;/li&gt;
&lt;li&gt;file-backed 페이지들은 디스크에 원본이 있으므로 스왑 영역 이외에 swap out할 수 있다(원본 영역)&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;21.3 페이지 폴트(page fault)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;페이지 폴트: 물리 메모리에 존재하지 않는 페이지에 접근하는 행위&lt;/li&gt;
&lt;li&gt;페이지 폴트 발생 시, 운영체제로 제어권이 넘어가 페이지 폴트 핸들러(page fault handler)가 실행된다&lt;/li&gt;
&lt;li&gt;요청된 페이지가 메모리에 없고, 디스크로 스왑되었다면, 운영체제는 페이지를 메모리로 스왑해온다&lt;/li&gt;
&lt;li&gt;해당 페이지의 스왑 공간상의 위치는 페이지 테이블에 저장되어있다&lt;/li&gt;
&lt;li&gt;페이지 폴트를 하드웨어로 처리하지 않는 이유는 페이지 폴트로 인한 디스크 접근이 느리기 때문이다&lt;/li&gt;
&lt;li&gt;그리고 페이지 폴트 처리를 위해 하드웨어가 스왑 공간의 구조, 디스크에 I/O 요청 등 세부 사항을 알아야 한다&lt;/li&gt;
&lt;li&gt;TLB 미스 발생 시, 세 가지의 중요한 경우가 있다&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;페이지 유효o/ 존재o: TLB미스 핸들러가 PTE(페이지 테이블)에서 PFN을 가져와 TLB 갱신 후 재시도 --&amp;gt; TLB 히트&lt;/li&gt;
&lt;li&gt;페이지 유효o/ 존재x: 페이지 폴트 핻들러 실행 --&amp;gt; 물리 메모리에 페이지 탑재 후 재시도&lt;/li&gt;
&lt;li&gt;페이지 유효x: 무효한 접근에 대한 트랩 핸들러 실행&lt;/li&gt;
&lt;/ol&gt;
&lt;ul&gt;
&lt;li&gt;페이지 폴트의 처리 과정:&lt;/li&gt;
&lt;/ul&gt;
&lt;ol&gt;
&lt;li&gt;탑재할 물리 프레임 확보&lt;/li&gt;
&lt;li&gt;교체 알고리즘 실행: 메모리에서 내보낼 페이지 결정 후 여유공간 확보&lt;/li&gt;
&lt;li&gt;I/O 요청으로 스왑 영역에서 페이지를 읽어온다&lt;/li&gt;
&lt;li&gt;페이지 테이블 갱신 후 명령어 재시도&lt;/li&gt;
&lt;li&gt;TLB 미스 처리 후 명령어 재시드 --&amp;gt; TLB 히트&lt;/li&gt;
&lt;/ol&gt;
&lt;h3&gt;22 물리 메모리 크기의 극복: 정책(policy)&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;교체 정책(replacement policy): 메모리에 여유 공간이 없을 경우, 내보낼 페이지를 결정하는 방식&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;22.1 캐시 관리&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;메인 메모리는 시스템의 가상 메모리(VM) 페이지를 가져다 놓기 위한 캐시로 생각할 수 있다&lt;/li&gt;
&lt;li&gt;캐시 미스의 최소화: 디스크로부터 페이지를 가져우는 횟수를 최소로 만드는 것&lt;/li&gt;
&lt;li&gt;캐시 히트 횟수 최대화: 접근된 페이지가 이미 존재하는 횟수를 최대로 하는 것&lt;/li&gt;
&lt;li&gt;평균 메모리 접근 시간(AMAT, average memory access time) = P_hit * T_M + P_miss * T_D&lt;/li&gt;
&lt;li&gt;P_hit(캐시 히트 확률), P_miss(캐시 미스 확률), T_M(메모리 접근 비용), T_D(디스크 접근 비용)&lt;/li&gt;
&lt;li&gt;T_D 디스크 접근 비용이 매우매우 크기 때문에 P_miss를 줄여야한다!&lt;/li&gt;
&lt;li&gt;캐시 미스를 최대한 줄여야 하는 것이 교체 정책의 목표이다&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;최적 교체 정책(the optimal replacement policy)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;Belady 선생께서 말씀하시길, &amp;quot;가장 나중에 접근될 페이지를 교체하는는 것이 최적이며, 가장 적은 횟수의 미스를 발생시킨다&amp;quot;&lt;/li&gt;
&lt;li&gt;가장 먼 시점에 필요한 페이지보다 캐시에 존재하는 다른 페이지들이 더 중요하다&lt;/li&gt;
&lt;li&gt;미래를 알 수 없기에 최적 기법의 구현은 불가능&lt;/li&gt;
&lt;li&gt;다른 정책의 비교 기준으로 사용 --&amp;gt; &amp;quot;정답에 얼마나 가까운지&amp;quot;&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;FIFO&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;가장 먼저 들어온 페이지부터 교체&lt;/li&gt;
&lt;li&gt;순차 반복 입력에서 안좋은 성능&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;무작위 선택(random)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;내보낼 페이지 무작위로 선택&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;과거 정보의 사용: LRU(least recently used)&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;미래 예측을 위해 과거 사용 이력 확인&lt;/li&gt;
&lt;li&gt;지역성의 원칙: 최근에 접근된 페이지일수록 가까운 미래에 접근될 확률이 높을 것&lt;/li&gt;
&lt;li&gt;순차 반복 입력에서 안좋은 성능&lt;/li&gt;
&lt;li&gt;구현이 어려움: 어떤 페이지가 가장 최근, 오래 전에 참조되었는지 관리하기 위해 모든 메모리 참조 정보를 기록해야 함&lt;/li&gt;
&lt;li&gt;LRU 근사 정책 출현&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;LRU 근사 정책&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;use bit(reference bit) 사용: 페이지가 참조될 때마다 하드웨어에 의해 use bit = 1로 설정, use bit = 0으로 바꾸는 것은 운영체제의 몫&lt;/li&gt;
&lt;li&gt;clock algorithm: 페이지를 환형 리스트로 구성하고, 페이지 교체 시 현재 바늘이 가리키고 있는 페이지의 use bit 검사&lt;/li&gt;
&lt;li&gt;use bit = 1 이면 최근에 참조된 페이지 --&amp;gt; 0 으로 변경 후 다음 페이지 이동&lt;/li&gt;
&lt;li&gt;use bit = 0 인 페이지를 발견할 때까지 반복 --&amp;gt; use bit = 0 인 페이지는 최근에 참조된 적이 없는 페이지&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;갱싱된 페이지 고려: dirty bit&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;변경된 페이지 내보낼 때, 디스크에 변경 내용을 기록해야 함&lt;/li&gt;
&lt;li&gt;더티 페이지(변경된 페이지)를 내보낼 때 추가적인 I/O 필요하기 때문에 깨끗한 페이지(변경되지 않은 페이지)를 내보내는 것 선호&lt;/li&gt;
&lt;li&gt;이를 위해 dirty bit를 추가하여 페이지 변경 상태를 기록&lt;/li&gt;
&lt;li&gt;예를 들어, 시계 알고리즘에서 &amp;quot;사용되지 않은 상태(use bit = 0)이고, 깨끗한(dirty bit = 0)인 페이지&amp;quot;를 먼저 찾도록 함&lt;/li&gt;
&lt;/ul&gt;
&lt;h4&gt;기타 용어들&lt;/h4&gt;
&lt;ul&gt;
&lt;li&gt;요구 페이징 정책(demanding paging): 페이지가 실제로 접근될 때, 운영체제가 해당 페이지를 메모리로 읽어들인다.&lt;/li&gt;
&lt;li&gt;클러스터링(clustering), 모으기(gathering): 운영체제가 변경된 페이지를 디스크에 반영할 때, 기록해야 할 페이지들을 모은 후 한번에 디스크에 기록( 디스크는 여러 개의 작은 쓰기 요청을 처리하는 것보다 하나의 큰 쓰기 요청을 더 효율적으로 처리할 수 있다)&lt;/li&gt;
&lt;li&gt;쓰래싱(thrashing): 메모리 사용 요구가 감당할 수 없을 만큼 많고, 실행 중인 프로세스가 요구하는 메모리가 가용 물리 메모리 크기를 초과하는 경우 시스템은 끊임없이 페이징 시도&lt;/li&gt;
&lt;/ul&gt;</description>
      <category>dev/SW정글</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/58</guid>
      <comments>https://blog.realbro.dev/58#entry58comment</comments>
      <pubDate>Thu, 28 Oct 2021 10:32:47 +0900</pubDate>
    </item>
    <item>
      <title>PINTOS 2-3주차: USER PROGRAM</title>
      <link>https://blog.realbro.dev/57</link>
      <description>&lt;h1&gt;User Programs&lt;/h1&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;프로젝트 2를 하며 느낀점:&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;이번 프로젝트는 코드 분석이 전부였다. 다행히 프로젝트2를 통과한 분의 코드를 구할 수 있었다. 먼저 공식 문서를 보며 어떤 것이 필요하고 무엇을 구현해야 하는지 파악했다. 그리고 그 분의 코드를 분석하며 어떻게 요구사항을 맞추었는지 정리했다. 저번과는 달리 코드의 깊이가 상당했다. 함수 하나를 보면 타고 타고 가서 처음에는 압도됐다. 한번 보는 것으로는 이해할 수 없었다. 괜찮다. 2번보고 3번보고 계속 보면 된다. 볼수록 저번에 이해할 수 없었던 부분들이 보이기 시작하고 전체적인 흐름을 알 수 있었다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;실제 구현 위주로 이번 프로젝트를 한 분들도 많다. 그런 분들을 보면서 나도 구현 위주로 했어야 하나 하느 생각도 든다. 하지만 이번 핀토스를 하면서 어떤 길을 택하든 모든 길에 의미가 있다고 생각한다. 우리에게 주어진 시간이 많지 않다. 그리고 기반 지식도 부족하다. 코드 구현을 중점으로 하면 코드 구현 능력이 향상될 것이고, 코드 분석을 위주로 하면 몇천줄의 복잡한 코드를 빠르게 이해하는 능력을 기를 수 있을 것이다. 심지어 그냥 OS 공부를 하는 것도 의미가 있다고 생각한다. os 지식을 바탕으로 핀토스 코드를 다시 봤을 때, 실제로 어떻게 적용이 되었는지 깨달을 수 있다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;이번 프로젝트를 통해 어떤 복잡한 코드가 주어져도 70% 정도는 이해할 수 있다는 느낌이 들었다. 결국 함수를 타고 가면서 역할과 의미를 하나하나 따져가면 될 것이다(시간은 많이 걸릴 지라도 점점 단축될 것이라 생각한다). 다음 프로젝트는 소스가 없을 것으로 생각한다. 하지만 코드 분석을 중점적으로 생각한다면 굳이 새 핀토스 버전이 아니어도 괜찮고 테스트 통과에 대한 생각도 잠시 내려놓아도 괜찮다고 생각한다. 구 버전의 소스(32 bit&amp;nbsp; PINTOS)를 분석하며 OS 지식이 어떻게 구현되어있는지 파악하고, 복잡한 함수를 해석하는 능력을 기르면 그 또한 의미가 있을 것이라고 생각한다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;이번 주차에 어떤 것을 했는지 밑에 적어놓았다.&lt;/p&gt;
&lt;h2 data-ke-size=&quot;size26&quot;&gt;&amp;nbsp;&lt;/h2&gt;
&lt;h2 data-ke-size=&quot;size26&quot;&gt;1 ARGUMENT PASSING&lt;/h2&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- 목표&lt;/h4&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;명령어와 함께 들어온 인자들을 user program의 user stack에 정해진 순서에 따라 넣어준다.&lt;/p&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- 예시&lt;/h4&gt;
&lt;ul style=&quot;list-style-type: disc;&quot; data-ke-list-type=&quot;disc&quot;&gt;
&lt;li&gt;'bin/ls -l foo bar'이 커맨드라인에 들어오면 argv[0] = 'bin/ls\0', 'argv[1] = -l\0', argv[2] = 'foo\0', argv[3] = 'bar\0'으로 parsing(문자열 분리)한 뒤에 아래와 같이 스택에 넣어준다.&lt;/li&gt;
&lt;li&gt;| argv[3] | ... | argv[0] | padding for 8 배수 | NULL pointer for argv[argc=4] | pointer for argv[3] | ... | pointer for argv[0] | return address = NULL |&lt;/li&gt;
&lt;li&gt;&amp;nbsp;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;&lt;figure class=&quot;imageblock alignCenter&quot; data-origin-width=&quot;987&quot; data-origin-height=&quot;655&quot; data-filename=&quot;user_stack.png&quot; data-ke-mobilestyle=&quot;widthOrigin&quot;&gt;&lt;span data-url=&quot;https://blog.kakaocdn.net/dn/blbwYp/btrhFQUzK3L/VFN97t6aHhLFJfJmjjGER1/img.png&quot; data-phocus=&quot;https://blog.kakaocdn.net/dn/blbwYp/btrhFQUzK3L/VFN97t6aHhLFJfJmjjGER1/img.png&quot;&gt;&lt;img src=&quot;https://blog.kakaocdn.net/dn/blbwYp/btrhFQUzK3L/VFN97t6aHhLFJfJmjjGER1/img.png&quot; srcset=&quot;https://img1.daumcdn.net/thumb/R1280x0/?scode=mtistory2&amp;fname=https%3A%2F%2Fblog.kakaocdn.net%2Fdn%2FblbwYp%2FbtrhFQUzK3L%2FVFN97t6aHhLFJfJmjjGER1%2Fimg.png&quot; data-origin-width=&quot;987&quot; data-origin-height=&quot;655&quot; data-filename=&quot;user_stack.png&quot; data-ke-mobilestyle=&quot;widthOrigin&quot; onerror=&quot;this.onerror=null; this.src='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png'; this.srcset='//t1.daumcdn.net/tistory_admin/static/images/no-image-v1.png';&quot;/&gt;&lt;/span&gt;&lt;/figure&gt;
&lt;/p&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- 코드&lt;/h4&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;1 file_name을 parsing하는 코드&lt;/p&gt;
&lt;pre class=&quot;reasonml&quot;&gt;&lt;code&gt;char *argv[30];
int argc = 0;

char *token, *save_ptr;  // argc = N+1; argv = {filename, arg1, ... argN}로 parsing
token = strtok_r(file_name, &quot; &quot;, &amp;amp;save_ptr);
while (token != NULL)
{
    argv[argc] = token;
    token = strtok_r(NULL, &quot; &quot;, &amp;amp;save_ptr);    // 두번째 parsing부터는 첫번째 인자를 NULL로 한다
    argc++;
}&lt;/code&gt;&lt;/pre&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;2 strtok_r 함수: 문자열 파싱하는 함수&lt;/p&gt;
&lt;pre class=&quot;cpp&quot;&gt;&lt;code&gt;char *
strtok_r (char *s, const char *delimiters, char **save_ptr) {
    char *token;

    ASSERT (delimiters != NULL);
    ASSERT (save_ptr != NULL);

    /* If S is nonnull, start from it.
       If S is null, start from saved position. */
    if (s == NULL)
        s = *save_ptr;
    ASSERT (s != NULL);

    /* Skip any DELIMITERS at our current position. */
    while (strchr (delimiters, *s) != NULL) {
        /* strchr() will always return nonnull if we're searching
           for a null byte, because every string contains a null
           byte (at the end). */
        if (*s == '\0') {
            *save_ptr = s;
            return NULL;
        }

        s++;
    }

    /* Skip any non-DELIMITERS up to the end of the string. */
    token = s;
    while (strchr (delimiters, *s) == NULL)
        s++;
    if (*s != '\0') {
        *s = '\0';
        *save_ptr = s + 1;
    } else
        *save_ptr = s;
    return token;
}&lt;/code&gt;&lt;/pre&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;2 parsed arguments를 user stack에 넣어주는 함수&lt;/p&gt;
&lt;pre class=&quot;cpp&quot;&gt;&lt;code&gt;void load_userStack(char **argv, int argc, void **rspp)
{
    // 1. Save argument strings (character by character)
    for (int i = argc - 1; i &amp;gt;= 0; i--)
    {
        int N = strlen(argv[i]);
        for (int j = N; j &amp;gt;= 0; j--)
        {
            char individual_character = argv[i][j];    // argv - i번째 스트링의 j번째 character; '\0'부터 거꾸로 시작
            (*rspp)--;        // (*rspp) = _if.rsp (unsigned long int: 8 byte 정수로 주소값 표현?) --&amp;gt; _if.rsp 1 감소 (1 byte 전 주소값으로 이동?)
            **(char **)rspp = individual_character; // rspp를 (char **)로 캐스팅하면, **(char **)rspp = *(char *)rsp = (char)(메모리)
        }
        // *(char **)rspp 는 (char *)형 포인터!
        argv[i] = *(char **)rspp; // (char *) 포인터..push this address too; 3번에 사용할 것
    }

    // 2. Word-align padding
    int pad = (int)*rspp % 8;        // (*rspp): _if.rsp 주소값 --&amp;gt; 8로 나눈 나머지
    for (int k = 0; k &amp;lt; pad; k++)    // pad만큼 주소값--; 주소 번지를 8의 배수 맞추기 위해
    {
        (*rspp)--;                    // _if.rsp 주소값 -1 이동
        **(uint8_t **)rspp = (uint8_t)0; // _if.rsp가 가리키는 내용물으 0으로 채움(1 byte)
    }

    // 3. Pointers to the argument strings
    size_t PTR_SIZE = sizeof(char *);

    (*rspp) -= PTR_SIZE;            // _if.rsp를 8byte 내림
    **(char ***)rspp = (char *)0;    // NULL포인터로 채움 argv[argc]

    for (int i = argc - 1; i &amp;gt;= 0; i--)
    {
        (*rspp) -= PTR_SIZE;        // 8byte 이동하면서 각 argv[i]가 저장된 스택의 주소값(char *) 기록(위-위 for문 마지막에 저장한 것)
        // 하고싶은 것: _if.rsp가 가리키는 곳에 argv[i] (char * 자료형) 을 기입하고 싶음 --&amp;gt; *(char **)_if.rsp = argv[i] 를 해주고 싶은 것! &amp;lt;-- 캐스팅하는 이유는 (char *)를 기록해야 하므로
        **(char ***)rspp = argv[i];    // argv[i]는 (char *)이고, *rspp가 _if.rsp --&amp;gt; (char ***)rspp 로 캐스팅하면
                                    //                            rspp는 (char ***), *rsp == _if.rsp는 (char **)형으로 캐스팅된 것..!: 원하는 결과
                                    // 즉, *(char **)_if.rsp = argv[i]   &amp;lt;==&amp;gt;  **(char ***)rspp = argv[i]
    }

    // 4. Return address
    (*rspp) -= PTR_SIZE;
    **(void ***)rspp = (void *)0;    // 마지막 return add도 void형 포인터 NULL 기입
}&lt;/code&gt;&lt;/pre&gt;
&lt;h2 data-ke-size=&quot;size26&quot;&gt;2 SYSTEM CALLS&lt;/h2&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;각 system call 함수의 흐름을 정리했다&lt;/p&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- halt()&lt;/h4&gt;
&lt;pre class=&quot;isbl&quot;&gt;&lt;code&gt;halt() --&amp;gt; power_off()&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- exit()&lt;/h4&gt;
&lt;pre class=&quot;html xml&quot; data-ke-language=&quot;html&quot;&gt;&lt;code&gt;exit() --&amp;gt; thread_exit() --&amp;gt; process_exit(): 

                                        --&amp;gt; 열린 파일들 닫기
                                        --&amp;gt; palloc_free_multiple(): free fdt
                                        --&amp;gt; file_close(): 현재 실행중인 executable file 닫기
                                        --&amp;gt; process_cleanup(): free current process's resources
                                        --&amp;gt; sema_up(wait_sema): process_wait()에 sema_down(wait_sema)에 막혀 잠든 부모 스레드 깨운다
                                        --&amp;gt; sema_down(free_sema): 부모 프로세스가 sema_up(free_sema)할때까지 잠듦

                         --&amp;gt; do_schedule(THREAD_DYING&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- fork()&lt;/h4&gt;
&lt;pre class=&quot;livescript&quot;&gt;&lt;code&gt;(부모 스레드)
process_fork(thread_name, intr_frame)

 -&amp;gt; memcpy(&amp;amp;cur-&amp;gt;parent_if, if_,): to pass this intr_frame down to child
--&amp;gt; thread_create(, __do_fork, cur): [자식 스레드]
                                    --&amp;gt; do_fork(cur):
                                                     --&amp;gt; 1. 부모 스레드의 cpu context 복사(intr_frame)
                                                     --&amp;gt; 2. page table 복사
                                                     --&amp;gt; sema_up(&amp;amp;current-&amp;gt;fork_sema): wake up parrent process
                                                     --&amp;gt; do_iret(): switch to newly created process
                                                     --&amp;gt; 종료

--&amp;gt; sema_sown(&amp;amp;child-&amp;gt;fork_se ma): child thread가 실행되어 __do_fork에서 sema_up()하기까지 기다림
--&amp;gt; return tid&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- exec()&lt;/h4&gt;
&lt;pre class=&quot;livescript&quot;&gt;&lt;code&gt;fn_copy = palloc_get_page(): 파일 이름 동적할당하여 복사할 공간 확보
strlcpy(): 복사 후 넘겨주기(process_cleanup()에서 다 날라가나?)

process_exec(fn_copy):
                      --&amp;gt; intr_frame 생성
                      --&amp;gt; process_cleanup(): kill the current context
                      --&amp;gt; argument parsing(게시글 맨 위 argument passgin 부분 참고)
                      --&amp;gt; load(file_name, &amp;amp;_if): 실행파일을 메모리에 로딩
                      --&amp;gt; load_userStack(): parsed arguments를 userstack에 올림
                      --&amp;gt; do_iret(): switch process&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- process_wait()&lt;/h4&gt;
&lt;pre class=&quot;reasonml&quot;&gt;&lt;code&gt;get_child_with_pid()
sema_down(&amp;amp;child-&amp;gt;wait_sema): [부모 스레드 잠듬] wait_sema가 0으로 초기화되어 있어 
                              자식 스레드가 process_exit()에서 sema_up(wait_sema)호출할때까지 기다림

                            --&amp;gt; [자식 스레드] process_exit()
                            --&amp;gt; ... process_cleanup()
                            --&amp;gt; sema_up(&amp;amp;cur-&amp;gt;wait_sema): process_wait()으로 잠든 부모 스레드 깨움
                            --&amp;gt; sema_down(&amp;amp;cur-&amp;gt;free_sema): [자식 스레드 잠듬] 부모 스레드가 자식 리스트 지울 때까지 기다림

                            &amp;lt;-- [부모 스레드]
exit_status = child-&amp;gt;exit_status : 자식 스레드의 종료 status 기록(child-&amp;gt;exit_status는 자식 스레드가 syscall.c/exit()호출할때 변경)
list_remove(): 자식 스레드 리스트에서 제거
sema_up(&amp;amp;child-&amp;gt;free_sema): 자고 있는 자식 스레드 깨움

                            --&amp;gt; [자식 스레드] process_exit() 종료&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;- create()&lt;/h4&gt;
&lt;pre class=&quot;livescript&quot;&gt;&lt;code&gt;filesys_create(file, initial_size)

 -&amp;gt; 1. dir_open_root(): 루트 디렉토리 inode를 메모리로 로딩

                        --&amp;gt; inode_opedn(ROOT_DIR_SECTOR): 루트 섹터에서 inode를 읽어들임

                                        --&amp;gt; 이미 열려있는 inode인지 확인 후 reopen(): open_inodes 리스트 순회
                                        --&amp;gt; 아닌 경우, inode 메모리 동적할당
                                        --&amp;gt; inode 초기화: open_inodes 리스트에 추가, 기본 멤버 초기화
                                        --&amp;gt; disk_read(): 디스크 SECTOR에 저장된 정보를 inode-&amp;gt;data에 저장
                                        --&amp;gt; return inode

                        --&amp;gt; dir_open(inode): dir 자료구조 메모리 할당 및 inode 연결

--&amp;gt; 2. free_map_allocate(1, &amp;amp;inode_sector): 디스크에서 1 sector 할당(생성할 파일 inode 기록하기 위한 공간?)
--&amp;gt; 3. inode_create(inode_sector, initial_size): file의 inode를 작성하고(메모리에서) 디스크(inode_sector)에 기록

                        --&amp;gt; disk_inode 동적할당(디스크에 쓸 자료구조)
                        --&amp;gt; disk_inode멤버 초기화: 파일 크기 크기, 등
                        --&amp;gt; free_map_allocate(): 파일 크기에 해당하는 sector 수만큼 디스크 할당
                        --&amp;gt; disk_write(): 디스크에 disk_inode 기록
                        --&amp;gt; disk_write(): 디스크에 파일 기록
                        --&amp;gt; disk_inode 동적 해제

--&amp;gt; 4. dir_add(): 열려 있는 루트 디렉토리에 새로 만든 파일 아이노드 엔트리 추가하고 디스크에 기록

                        --&amp;gt; lookup(): DIR 내 동일 이름 파일 있는지 검사
                        --&amp;gt; dir-&amp;gt;inode에서 비어있는 엔트리 찾는다: 해당 ofs(오프셋)값을 찾는다 
                        --&amp;gt; dir-&amp;gt;inode 해당 엔트리에 생성된 파일 inode정보(멤버) 기록: in_use, name, sector 등
                        --&amp;gt; inode_write_at(): 디스크에 저장

--&amp;gt; 5. dir_close(): 루트 디렉토리 inode메모리 해제

                    --&amp;gt; inode_close(dir-&amp;gt;inode): inode.open_cnt를 하나 내리고 0이 되면 비로소 메모리에서 지운다

                                            --&amp;gt; list_remove(): open_inodes 리스트에서 지운다
                                            --&amp;gt; 디스크에서 해당 섹터를 할당 해제한다(inode-&amp;gt;sector: inode자체, inode-&amp;gt;data: inode에 해당하는 파일)
                                            --&amp;gt; free(inode) 

                    --&amp;gt; free(dir)&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;remove()&lt;/h4&gt;
&lt;pre class=&quot;livescript&quot;&gt;&lt;code&gt;filesys_remove()

 -&amp;gt; dir_open_root(): root 디렉토리 연다
--&amp;gt; dir_remove(): 디렉토리에서 해당 엔트를 사용안함처리하고, 아이노드 removed=true 처리

                --&amp;gt; lookup(): 디렉토리에서 파일 이름을 가진 엔트리 찾는다(offset)
                --&amp;gt; inode_open(): 엔트리에 해당하는 아이노드를 연다
                --&amp;gt; e.in_use=true: 해당 엔트리 사용안함처리
                --&amp;gt; inode_write_at(): 디렉토리의 해당 엔트리 갱신(사용안함처리했으므로)
                --&amp;gt; inode_remove(inode): 해당 아이노드를 deleted 처리

                                    --&amp;gt; inode-&amp;gt;removed=true

--&amp;gt; inode_close(inode): inode-&amp;gt;opencnt를 하나 내리고 0이 되면 메모리에서 내린다
--&amp;gt; dir_close(): 루트 디렉토리를 닫는다&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;open()&lt;/h4&gt;
&lt;pre class=&quot;http&quot;&gt;&lt;code&gt;filesys_open(): 파일을 연다

            --&amp;gt; dir_open_root(): 루트 디렉토리 연다
            --&amp;gt; dir_lookup(): 디렉토리 엔트리 검색 -&amp;gt; 찾은 파일의 inode를 open_inodes리스트에 추가
            --&amp;gt; dir_close(): 루트 디렉토리 닫는다
            --&amp;gt; file_open(inode): 메모리에 file 자료구조 할당 후 해당 파일의 inode 포인팅 및 초기화

                                --&amp;gt; file 구조체 동적 할당
                                --&amp;gt; 파일 멤버 초기화: inode와 연결

add_file_to_fdt(): 현재 실행 스레드의 FDT(file descriptor table)의 비어있는 인덱스에 파일 할당&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;filesize()&lt;/h4&gt;
&lt;pre class=&quot;xl&quot;&gt;&lt;code&gt;find_file_by_fd(): 현재 실행 스레드의 fdt에서 fd번째 파일 찾는다
file_length(): 해당 파일의 길이(파일 -&amp;gt; inode -&amp;gt; inode-&amp;gt;data.length)

             --&amp;gt; inode_length(file-&amp;gt;inode) --&amp;gt; inode-&amp;gt;data.length&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;seek()&lt;/h4&gt;
&lt;pre class=&quot;stylus&quot;&gt;&lt;code&gt;find_file_by_fd(): 현재 실행 스레드의 fdt에서 fd번째 파일 찾는다
fileobj-&amp;gt;pos = position: 다음에 읽을 곳(pos)을 변경한다&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;tell()&lt;/h4&gt;
&lt;pre class=&quot;stylus&quot;&gt;&lt;code&gt;find_file_by_fd(): 현재 실행 스레드의 fdt에서 fd번째 파일 찾는다
file_tell(): 현재 파일에서 다음에 읽을 곳 반환

        --&amp;gt; file-&amp;gt;pos&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;read()&lt;/h4&gt;
&lt;pre class=&quot;reasonml&quot;&gt;&lt;code&gt;find_file_by_fd(): 현재 실행 스레드의 fdt에서 fd번째 파일 찾는다
CASE1: STDOUT --&amp;gt; X
CASE2: STDIN  --&amp;gt; input_getc()로 한글자씩 버퍼에 복사
ELSE : 
        lock_acquire(rw_lock): rw 접근 하나의 스레드만?
        file_read() -&amp;gt; inode_read_at(): read SIZE byes from INODE into BUFFER; 어렵다
        lock_release(rw_lock)&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;write()&lt;/h4&gt;
&lt;pre class=&quot;reasonml&quot;&gt;&lt;code&gt;find_file_by_fd(): 현재 실행 스레드의 fdt에서 fd번째 파일 찾는다
CASE1: STDIN  --&amp;gt; X
CASE2: STDOUT --&amp;gt; putbuf()로 출력?
ELSE : 
        lock_acquire(rw_lock): rw 접근 하나의 스레드만?
        file_write() -&amp;gt; inode_write_at(): write SIZE bytes from BUFFER into INODE; 어렵다
        lock_release(rw_lock)&lt;/code&gt;&lt;/pre&gt;
&lt;h4 data-ke-size=&quot;size20&quot;&gt;close()&lt;/h4&gt;
&lt;pre class=&quot;http&quot;&gt;&lt;code&gt;find_file_by_fd(): 현재 실행 스레드의 fdt에서 fd번째 파일 찾는다
CASE1: STDIN  --&amp;gt; cur-&amp;gt;stdin_count--;
CASE2: STDOUT --&amp;gt; cur-&amp;gt;stdout_count--;
remove_file_from_fdt(): 해당파일 fdt에서 제거

IF CASE1 OR CASE2: return
IF file0&amp;gt;dupCount != 0: file-&amp;gt;dupCount --;
ELSE:
    file_close(): 
                --&amp;gt; file_allow_write(file): 쓰기 허용
                --&amp;gt; inode_close(file-&amp;gt;inode): inode를 메모리에서 내린다

                                --&amp;gt; if (--inode-&amp;gt;open_cnt == 0): open_cnt를 하나 내리고 0이 되면
                                --&amp;gt; list_remove(): open_inodes리스트에서 해당 아이노드 삭제
                                --&amp;gt; 그리고 inode-&amp;gt;removed=true(아이노드 삭제 처리되었을때)
                                --&amp;gt; 디스크에서 아이노드 부분과 아이노드가 가리키는 파일 부분의 블록 할당 해제 
                                --&amp;gt; free(inode)

                --&amp;gt; free(file)&lt;/code&gt;&lt;/pre&gt;</description>
      <category>dev/SW정글</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/57</guid>
      <comments>https://blog.realbro.dev/57#entry57comment</comments>
      <pubDate>Wed, 13 Oct 2021 17:10:52 +0900</pubDate>
    </item>
    <item>
      <title>PINTOS 1주차: priority scheduling</title>
      <link>https://blog.realbro.dev/56</link>
      <description>&lt;p data-ke-size=&quot;size16&quot;&gt;&lt;span style=&quot;font-family: 'Noto Serif KR';&quot;&gt;1주일 동안 한 것을 정리하려 한다. 짧은 기간이었지만 꽤 많은 것을 공부했다.&lt;/span&gt;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;pintos project1은 priority scheduling에 관한 것이었다. 바로 프로젝트를 하기 전에 scheduling에 대한 이해가 필요했다. CSAPP, youtube 강의, 블로그 등을 통해 scheduling에 대해 공부했다.&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;cpu는 기본적으로 한가지 프로세스 혹은 스레드에 대한 작업을 하지만 우리는 컴퓨터로 여러 작업을 동시에 할 수 있다. 이는 os가 여러 프로세스를 짧게 나누어 번갈아가면서 실행해 동시에 프로세스들이 실행된다고 느끼게 하는 것이다. 예전에는 한 프로세스가 끝날 때까지 다른 작업을 할 수 없었다고 한다고 들은 것 같다. 이를 '동시성 프로그래밍'이라고 한다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;여기서 문제가 생기는 것이 공유 자원에 대한 처리이다. 프로세스가 전환되는 것을 컨텍스트 스위칭이라 한다. 프로세스 A가 공유자원에 접근하여 갱신하고 저장하기 전에 컨텍스트 스위칭이 일어날 수 있다. 이 때 다른 프로세스 B가 이 공유자원에 접근하면 예전 값을 얻게 되고 이 상태에서 갱신, 저장을 한다. 다시 컨텍스트 스위칭이 일어나 프로세스 A가 작업을 이어가면 공유자원은 B가 갱신하기 전 값으로 다시 회귀하여 저장하게 된다. 즉, 같은 공유 자원에 접근할 때 '읽기 - 갱신 - 저장'은 한번에 한 프로세스만 접근할 수 있게 해야 한다. 이를 크리티컬 섹션이라고 한다. 그리고 이를 보장하는 것을 원자성이라고 한 것 같다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;공유자원 문제를 해결하기 위한 방법으로 3가지가 주어졌다. 이는 세마포어, 락, 모니터이다. 너무 길어질 것 같아 자세한 설명은 생략한다. 구글에 검색하면 이 글에서보다 훨씬 이해하기 쉬울 것이다. 이 중 세마포어를 중점적으로 사용하여 스레드간의 동시성 공유자원 문제를 해결했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;1) alarm clock&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;기존 코드는 ready상태의 스레드들을 계속 깨우고 잠재우는 busy-waiting 방식이었다. 이를 개선하는 것이 이 프로젝트의 목표였다. 이를 위해 각 스레드마다 잠들 때 일어나야 할 시간(wakeup_tick)을 저장하고, sleep_list를 통해 잠든 스레드들을 관리했다. 그리고 일어나야 할 시간이 되었을 때 sleep_list에서 해당 스레드를 깨우는 방식으로 구현했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;2) priority scheduling(1)&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;기존 코드는 스레드 간의 priority가 없었다. priority란 우선순위로 ready상태의 스레드를 깨울 때 우선순위가 높은 스레드를 먼저 깨우는 것이다. 이를 위해 스레드 풀에 변동이 생길 때(생성, sleep, unblock) 스레드 우선순위를 비교하여 가장 높을 스레드를 올리도록 하였다. ready_list를 정렬하여 맨 앞이 가장 높은 우선순위를 가지도록 했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;3) priority scheduling(2)&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;공유자원 관리에 관한 내용이었다. 세마포어, 락, 모니터에 priority를 적용했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;4) priority schdduling(3)&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;priority를 적용했을 때 생기는 문제점은 우선순위가 낮은 스레드가 lock을 가지고 있을 때, 우선순위와 다르게 실행 순서가 꼬일 수 있는 점이다. 이를 해결하기 위해 우선순위가 높은 스레드가 lock을 요청하면 낮은 스레드가 priority를 받아 먼저 lock을 풀 수 있도록 했다.&amp;nbsp; 이에 각 스레드마다 원래 priority, 기부받아 조정된 priroty, 기부받은 list(받았을 때), 기다리는 lock 종류(기부 할 때) 항목을 추가했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;이를 위해 lock_acquire(), lock_release(), donate_priority(), remove_with_lock(), refresh_priority()등의 함수를 수정하거나 새로 추가했다.&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;느낀점:&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;핀토스 프로젝트를 제로 베이스부터 1주일 동안 하는 것은 매우 어렵다. 운영체제가 어떻게 동작하는지에 대한 개념을 알고 핀토스에서 어떻게 구현되었는지 중점적으로 확인하는 식으로 공부했다. 코드를 분석하면서 이론에서 배운 개념이 어떻게 적용되었는지 확인했다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;코드 분석하는 실력이 많이 향상될 것 같다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;그리고 운영체제의 개념들이 왜 필요한지 이해하는 계기가 되었다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;2주차부터는 조금 더 체계적으로 해야겠다.&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;
&lt;p data-ke-size=&quot;size16&quot;&gt;&amp;nbsp;&lt;/p&gt;</description>
      <category>dev/SW정글</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/56</guid>
      <comments>https://blog.realbro.dev/56#entry56comment</comments>
      <pubDate>Mon, 4 Oct 2021 10:54:14 +0900</pubDate>
    </item>
    <item>
      <title>(c lang) RB-tree(red black tree) 구현</title>
      <link>https://blog.realbro.dev/21</link>
      <description>&lt;h1&gt;RB-tree&lt;/h1&gt;
&lt;ol&gt;
&lt;li&gt;insert 함수는 Jenny&amp;#39;s lectures CS/IT NET&amp;amp;JRF 유튜브 강의를 참고했습니다  &lt;a href=&quot;https://www.youtube.com/watch?v=qA02XWRTBdw&amp;amp;list=WL&amp;amp;index=2&amp;amp;t=3s&amp;amp;ab_channel=Jenny%27slecturesCS%2FITNET%26JRF&quot;&gt;[rbtree insert 유튜브 강의 바로가기]&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;delete 함수는 introduction to algorithms(Thomas H. Cormen 등)을 참고했습니다&lt;/li&gt;
&lt;/ol&gt;
&lt;hr&gt;
&lt;h2&gt;tree 구조체&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;root 노드 포인터를 멤버로 가져 트리 전체를 가리킨다&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;typedef struct {
  node_t *root;
} rbtree;

rbtree *new_rbtree(void) {
  rbtree *p = (rbtree *)calloc(sizeof(rbtree), 1);
  return p;
}&lt;/code&gt;&lt;/pre&gt;&lt;h2&gt;node 구조체&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;color(red, black), key, parent, left-child, right-child를 멤버로 갖는다&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;typedef enum { RBTREE_RED, RBTREE_BLACK } color_t;
typedef int key_t;

typedef struct node_t {
  color_t color;
  key_t key;
  struct node_t *parent, *left, *right;
} node_t;&lt;/code&gt;&lt;/pre&gt;&lt;h2&gt;node insert 함수&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;red 색상을 갖는 새 노드 생성&lt;/li&gt;
&lt;li&gt;일반적인 BST(binary-search-tree) 규칙으로 먼저 노드를 추가(루트일 경우 black으로 변경)&lt;/li&gt;
&lt;li&gt;red-red-conflict(새 노드와 그 부모가 모두 red일 경우, left_rotate(), right_rotate(), recolor() 등의 추가적인 조작 필요&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;node_t *new_RED_node(key_t key);
void recolor(node_t *curr);
void left_rotate(rbtree *t, node_t* x);
void right_rotate(rbtree *t, node_t* x);
void recolor_rotate(rbtree *t, node_t *new_node);

node_t *rbtree_insert(rbtree *t, const key_t key) {

  // make new &amp;quot;RED&amp;quot;node with given key
  node_t *new_node = new_RED_node(key);

  // 일단 적절한 위치에 new_node 추가
  // empty tree인 경우 함수 탈출
  if (insert_node_helper(t, new_node, key)) return new_node;

  // non-empty cases below: 추가적인 조작 필요(recolor &amp;amp; rotation)
  node_t *curr = new_node;
  node_t *par_node = new_node-&amp;gt;parent;

  // handle red-red confilct
  while (par_node-&amp;gt;color != RBTREE_BLACK){

    // determine uncle node
    node_t *uncle_node = NULL;
    if (par_node-&amp;gt;parent-&amp;gt;left == par_node) uncle_node = par_node-&amp;gt;parent-&amp;gt;right;
    else uncle_node = par_node-&amp;gt;parent-&amp;gt;left;

    // case1: uncle is NULL or black
    if (uncle_node == NULL || uncle_node-&amp;gt;color == RBTREE_BLACK){
      // do rotation and recolor
      recolor_rotate(t, curr);
      break;
    }
    // case2: uncle is red
    else{
      recolor(par_node);
      recolor(uncle_node);
      // 탈출조건
      if (par_node-&amp;gt;parent == t-&amp;gt;root) break;
      // 반복
      curr = par_node-&amp;gt;parent;
      par_node = curr-&amp;gt;parent;
      recolor(curr);
    }
  }
  return new_node;
}

void left_rotate(rbtree *t, node_t* x){
  //        |                 |
  //        x                 y
  //       / \               / \
  //      a   y             x   c
  //         / \           / \ 
  //        b   c         a   b

  // b를 x의 right-child로 이동
  node_t *y = x-&amp;gt;right;   // y: x의 right-child
  x-&amp;gt;right = y-&amp;gt;left;
  // b가 NULL인 경우 제외 
  if (y-&amp;gt;left != NULL) y-&amp;gt;left-&amp;gt;parent = x;
  // x의 부모 밑으로 y 연결
  y-&amp;gt;parent = x-&amp;gt;parent;

  if (t-&amp;gt;root == x) t-&amp;gt;root = y;   // x is root node
  else{     // x is not root node --&amp;gt; x의 기존 위치(left, right)에 y 추가
    if (x-&amp;gt;parent-&amp;gt;left == x) x-&amp;gt;parent-&amp;gt;left = y;
    else x-&amp;gt;parent-&amp;gt;right = y;
  }
  // x가 y의 left-child로 들어감
  y-&amp;gt;left = x;
  x-&amp;gt;parent = y;
}

void right_rotate(rbtree *t, node_t* x){
  //           |             |      
  //           x             y      
  //          / \           / \     
  //         y   c         a   x    
  //        / \               / \   
  //       a   b             b   c  

  // b를 x의 left-child로 이동
  node_t *y = x-&amp;gt;left;   // y: x의 left-child
  x-&amp;gt;left = y-&amp;gt;right;
  // b가 NULL인 경우 제외
  if (y-&amp;gt;right != NULL) y-&amp;gt;right-&amp;gt;parent = x;
  // x의 부모 밑으로 y 연결
  y-&amp;gt;parent = x-&amp;gt;parent;

  if (t-&amp;gt;root == x) t-&amp;gt;root = y;   // x is root node
  else{     // x is not root node --&amp;gt; x의 기존 위치(left, right)에 y 추가
    if (x-&amp;gt;parent-&amp;gt;left == x) x-&amp;gt;parent-&amp;gt;left = y;
    else x-&amp;gt;parent-&amp;gt;right = y;
  }
  // x가 y의 right-child로 들어감
  y-&amp;gt;right = x;
  x-&amp;gt;parent = y;
}

void recolor(node_t *curr){
  if (curr-&amp;gt;color == RBTREE_BLACK) curr-&amp;gt;color = RBTREE_RED;
  else curr-&amp;gt;color = RBTREE_BLACK;
}

void recolor_rotate(rbtree *t, node_t *new_node){

  // 일단 grand parent node는 recolor 대상
  recolor(new_node-&amp;gt;parent-&amp;gt;parent);

  // LL, LR, RR, RL의 경우에 따라 회전, recolor을 진행한다
  node_t *par_node = new_node-&amp;gt;parent;
  if (par_node-&amp;gt;parent-&amp;gt;left == par_node){
    // LL case
    if (par_node-&amp;gt;left == new_node){
      recolor(par_node);
      right_rotate(t, par_node-&amp;gt;parent);
    }
    // LR case
    else{
      recolor(new_node);
      left_rotate(t, par_node);
      right_rotate(t, new_node-&amp;gt;parent);
    }
  }
  else{
    // RR case
    if (par_node-&amp;gt;right == new_node){
      recolor(par_node);
      left_rotate(t, par_node-&amp;gt;parent);
    }
    // RL case
    else{
      recolor(new_node);
      right_rotate(t, par_node);
      left_rotate(t, new_node-&amp;gt;parent);
    }
  }
}

// make new node with red color
node_t *new_RED_node(key_t key){
  node_t *new_node = (node_t *)calloc(1, sizeof(node_t));
  new_node-&amp;gt;key = key;
  new_node-&amp;gt;color = RBTREE_RED;
  new_node-&amp;gt;parent = NULL;
  new_node-&amp;gt;left = NULL;
  new_node-&amp;gt;right = NULL;
  return new_node;
}&lt;/code&gt;&lt;/pre&gt;&lt;h2&gt;node erase 함수&lt;/h2&gt;
&lt;ol&gt;
&lt;li&gt;일반적인 BST트리 노드 제거&lt;/li&gt;
&lt;li&gt;잘려나간 노드가 black 노드일 경우 fix-up 조작을 통해 rb트리의 특성 보존&lt;/li&gt;
&lt;li&gt;double-black문제를 해결하기 위해 sibling노드의 색과 그 자식들의 색에 따라 case를 나눔&lt;/li&gt;
&lt;li&gt;delete할때만 introduction to algorithms 책에 나온 NIL노드를 도입하고 delete완료 후 NIL노드를 트리에서 제거함으로서 마지막 노드들은 NULL포인터를 가리키도록 함&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;// 가상의 NIL 노드(전역변수)
node_t nil_node = {RBTREE_BLACK, 777, NULL, NULL, NULL};
node_t * NIL = &amp;amp;nil_node;

// 첫 3개의 함수는 insert함수 밑에 첨부해서 여기서는 따로 코드 추가하지 않겠습니다
void left_rotate(rbtree *t, node_t* x);
void right_rotate(rbtree *t, node_t* x);
void recolor(node_t *curr);
void rbtree_delete_fixup(rbtree *t, node_t *x);
node_t *rbtree_delete(rbtree *t, node_t *target);

int rbtree_erase(rbtree *t, node_t *p) {
  // exception case: no nodes

  node_t *target = rbtree_delete(t, p);
  free(target);
  return 0;

// target 노드의 주소값을 받아 트리에서 제거
node_t *rbtree_delete(rbtree *t, node_t *target){

    // exception
    if (target == NULL) return NULL;

    // 1. splice 대상 y 결정

    // target의 자식 노드가 0, 1개인 경우: splice 대상 y는 target 자신
    node_t *y = NULL;
    if (target-&amp;gt;left == NULL || target-&amp;gt;right == NULL) y = target;
    // target의 자식 노드가 2개인 경우: splice 대상 y는 target 노드의 successor 노드
    else{
      y = target-&amp;gt;right;
      while (y-&amp;gt;left != NULL) y = y-&amp;gt;left;
    }

    // 2. y의 자식 노드 x 결정
    // y가 잘려나가면 그 밑의 노드를 이어주어야 하므로

    node_t *x = NULL;
    if (y-&amp;gt;left != NULL) x = y-&amp;gt;left;
    else x = y-&amp;gt;right;

    // 3. splicing y
    // exception: y가 root일 경우
    if (y-&amp;gt;parent == NULL) t-&amp;gt;root = x;
    else{
      // exception: x가 NULL인 경우: 가상의 전역변수 NIL노드를 부여
      if (x == NULL) x = NIL;


      // y의 위치에 따라 부모-자식 관계 재형성(x와 y-&amp;gt;parent)
      if (y == y-&amp;gt;parent-&amp;gt;left) y-&amp;gt;parent-&amp;gt;left = x;
      else y-&amp;gt;parent-&amp;gt;right = x;

      x-&amp;gt;parent = y-&amp;gt;parent;
    }

    // target의 자식이 2개인 경우: splicing 대상 y는 target이 아니라 target의 successor
    if (y != target){
      target-&amp;gt;key = y-&amp;gt;key;
      // target-&amp;gt;color = y-&amp;gt;color;
    }

    if (y-&amp;gt;color == RBTREE_BLACK){
      rbtree_delete_fixup(t, x);
    }
    // else{
    //   // NIL 노드 해제
    //   if (x == NIL){
    //     printf(&amp;quot;sdfsdfsdfn&amp;quot;);
    //     if (x-&amp;gt;parent-&amp;gt;left == x) x-&amp;gt;parent-&amp;gt;left == NULL;
    //     else x-&amp;gt;parent-&amp;gt;right == NULL;
    //   }
    // }
    if (NIL-&amp;gt;parent != NULL){
      if (NIL == NIL-&amp;gt;parent-&amp;gt;left) NIL-&amp;gt;parent-&amp;gt;left = NULL;
      else NIL-&amp;gt;parent-&amp;gt;right = NULL;

      NIL-&amp;gt;parent = NULL;
    }
    return y;
}

void rbtree_delete_fixup(rbtree *t, node_t *x){
  // iterate while x is not root and x is black
  while (x != NULL &amp;amp;&amp;amp; x-&amp;gt;parent != NULL &amp;amp;&amp;amp; x-&amp;gt;color == RBTREE_BLACK){
    // sibling node (whivh is &amp;#39;w&amp;#39; in textbook)
    node_t *sibling = NULL;
    // x is left child
    if (x == x-&amp;gt;parent-&amp;gt;left){
      sibling = x-&amp;gt;parent-&amp;gt;right;
      // case1: x(BB), w(R) --&amp;gt; p(x)는 자동 B 
      if(sibling-&amp;gt;color == RBTREE_RED){
        sibling-&amp;gt;color = RBTREE_BLACK;
        x-&amp;gt;parent-&amp;gt;color = RBTREE_RED;
        left_rotate(t, x-&amp;gt;parent);
        sibling = x-&amp;gt;parent-&amp;gt;right;
      }
      // case2: x(BB), w(B), wl(B), wr(B)
      if ((sibling-&amp;gt;left == NULL || sibling-&amp;gt;left-&amp;gt;color == RBTREE_BLACK) 
          &amp;amp;&amp;amp; (sibling-&amp;gt;right == NULL || sibling-&amp;gt;right-&amp;gt;color == RBTREE_BLACK)){
            sibling-&amp;gt;color = RBTREE_RED;
            x = x-&amp;gt;parent;
            // NIL NODE 제거 ///////////////////////
            if (x-&amp;gt;left == NIL){
              x-&amp;gt;left = NULL;
              NIL-&amp;gt;parent = NULL;
            }
      }
      else {
        // case3: x(BB), w(B), wl(R), wr(B)
        if (sibling-&amp;gt;right-&amp;gt;color == RBTREE_BLACK){
          sibling-&amp;gt;left-&amp;gt;color = RBTREE_BLACK;
          sibling-&amp;gt;color = RBTREE_RED;
          right_rotate(t, sibling);
          sibling = x-&amp;gt;parent-&amp;gt;right;
        }
        // case4: x(BB), w(B), wr(R)
        sibling-&amp;gt;color = x-&amp;gt;parent-&amp;gt;color;
        x-&amp;gt;parent-&amp;gt;color = RBTREE_BLACK;
        sibling-&amp;gt;right-&amp;gt;color = RBTREE_BLACK;
        left_rotate(t, x-&amp;gt;parent);
        // NIL NODE 제거 ///////////////////////
        if (x-&amp;gt;parent-&amp;gt;left == NIL){
          x-&amp;gt;parent-&amp;gt;left = NULL;
          NIL-&amp;gt;parent = NULL;
        }
        // terminate condition
        x-&amp;gt;parent = NULL;
      }
    }
    /////////////////////////////////////////////////
    // x is right child
    else {
      sibling = x-&amp;gt;parent-&amp;gt;left;
      // case1: x(BB), w(R) --&amp;gt; p(x)는 자동 B 
      if(sibling-&amp;gt;color == RBTREE_RED){
        sibling-&amp;gt;color = RBTREE_BLACK;
        x-&amp;gt;parent-&amp;gt;color = RBTREE_RED;
        right_rotate(t, x-&amp;gt;parent);
        sibling = x-&amp;gt;parent-&amp;gt;left;
      }
      // case2: x(BB), w(B), wl(B), wr(B)
      if ((sibling-&amp;gt;left == NULL || sibling-&amp;gt;left-&amp;gt;color == RBTREE_BLACK) 
          &amp;amp;&amp;amp; (sibling-&amp;gt;right == NULL || sibling-&amp;gt;right-&amp;gt;color == RBTREE_BLACK)){
            sibling-&amp;gt;color = RBTREE_RED;
            x = x-&amp;gt;parent;
            // NIL NODE 제거 ///////////////////////
            if (x-&amp;gt;right == NIL){
              x-&amp;gt;right = NULL;
              NIL-&amp;gt;parent = NULL;
            }
      }
      else {
        // case3: x(BB), w(B), wl(R), wr(B)
        if (sibling-&amp;gt;left-&amp;gt;color == RBTREE_BLACK){
          sibling-&amp;gt;right-&amp;gt;color = RBTREE_BLACK;
          sibling-&amp;gt;color = RBTREE_RED;
          left_rotate(t, sibling);
          sibling = x-&amp;gt;parent-&amp;gt;left;
        }
        // case4: x(BB), w(B), wr(R)
        sibling-&amp;gt;color = x-&amp;gt;parent-&amp;gt;color;
        x-&amp;gt;parent-&amp;gt;color = RBTREE_BLACK;
        sibling-&amp;gt;left-&amp;gt;color = RBTREE_BLACK;
        right_rotate(t, x-&amp;gt;parent);
        // NIL NODE 제거 ///////////////////////
        if (x-&amp;gt;parent-&amp;gt;right == NIL){
          x-&amp;gt;parent-&amp;gt;right = NULL;
          NIL-&amp;gt;parent = NULL;
        }
        // terminate condition
        x-&amp;gt;parent = NULL;
      }
    }
  } 
  if (x != NULL) x-&amp;gt;color = RBTREE_BLACK;
}&lt;/code&gt;&lt;/pre&gt;&lt;h2&gt;기타 함수들&lt;/h2&gt;
&lt;h3&gt;find 함수&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;루트 노드부터 각 노드의 키 값과 대소비교하여 left-subtree, right-subtree로 갈 것인지 결정&lt;/li&gt;
&lt;li&gt;종료조건1: 찾는 값이 없는 경우 끝까지 탐색하여 NULL에 도달 후 경고문과 함께 NULL 반환&lt;/li&gt;
&lt;li&gt;종료조건2: target key를 가진 노드의 주소 반환&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;node_t *rbtree_find(const rbtree *t, const key_t key) {
  node_t *curr = t-&amp;gt;root;
  //move to chile node
  while (curr != NULL &amp;amp;&amp;amp; curr-&amp;gt;key != key){
    // search left-subtree
    if (key &amp;lt; curr-&amp;gt;key) curr = curr-&amp;gt;left;
    // search left-subtree
    else curr = curr-&amp;gt;right;
  }
  // end of tree
  if (curr == NULL) printf(&amp;quot;cannot find a node with given value %d !!\n&amp;quot;, key);
  return curr;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;min, max 함수&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;min의 경우 트리의 가장 왼쪽에 있는 노드 반환&lt;/li&gt;
&lt;li&gt;max의 경우 트리의 가장 오른쪽에 있는 노드 반환&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;node_t *rbtree_min(const rbtree *t) {
  node_t *curr = t-&amp;gt;root;
  // move to most-left-outside node
  while (curr != NULL &amp;amp;&amp;amp; curr-&amp;gt;left != NULL) curr = curr-&amp;gt;left;
  return curr;
}

node_t *rbtree_max(const rbtree *t) {
  node_t *curr = t-&amp;gt;root;
  // move to most-right-outside node
  while (curr != NULL &amp;amp;&amp;amp; curr-&amp;gt;right != NULL) curr = curr-&amp;gt;right;
  return curr;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;tree print 함수&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;dfs로 트리 탐색(recursion)&lt;/li&gt;
&lt;li&gt;left-subtree출력 -&amp;gt; 현재 노드 출력 -&amp;gt; right-subtree 출력 순서&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;// print (key, color) of all nodes in RB-tree
int print_rbtree(node_t *curr){

  // base case
  if (curr == NULL) return 0;

  // recursive call: dfs
  print_rbtree(curr-&amp;gt;left);
  printf(&amp;quot;key: %d, color: &amp;quot;, curr-&amp;gt;key);
  if (curr-&amp;gt;color == RBTREE_BLACK) printf(&amp;quot;black\n&amp;quot;);
  else printf(&amp;quot;red\n&amp;quot;);
  print_rbtree(curr-&amp;gt;right);
  return 0;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;tree 전체 삭제 함수&lt;/h3&gt;
&lt;ol&gt;
&lt;li&gt;동적할당된 노드들과 트리 전체를 해제 후 삭제하는 함수&lt;/li&gt;
&lt;li&gt;dfs로 탐색하면서(recursion) 노드를 빠져나갈 때, 해당 노드 free&lt;/li&gt;
&lt;/ol&gt;
&lt;pre&gt;&lt;code&gt;int delete_rbtree_helper(node_t *curr)

void delete_rbtree(rbtree *t) {
  delete_rbtree_helper(t-&amp;gt;root);
  free(t);
}

int delete_rbtree_helper(node_t *curr){
  // base case
  if (curr == NULL) return 0;

  // recursive call: dfs
  delete_rbtree_helper(curr-&amp;gt;left);
  delete_rbtree_helper(curr-&amp;gt;right);
  // free memory escaping &amp;#39;curr&amp;#39; node
  free(curr);
  return 0;
}&lt;/code&gt;&lt;/pre&gt;</description>
      <category>dev/C lang</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/21</guid>
      <comments>https://blog.realbro.dev/21#entry21comment</comments>
      <pubDate>Thu, 9 Sep 2021 17:22:41 +0900</pubDate>
    </item>
    <item>
      <title>(c lang) binary search tree 구현</title>
      <link>https://blog.realbro.dev/20</link>
      <description>&lt;h4&gt;introduction to algorithms(Thomas H. Cormen...) 의 수도코드를 강력하게 참고했습니다&lt;/h4&gt;
&lt;hr&gt;
&lt;h3&gt;node 구조체 구현&lt;/h3&gt;
&lt;pre&gt;&lt;code&gt;// node definition
typedef struct node{
    int key;
    struct node *parent;
    struct node *left;
    struct node *right;
} node_t&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;tree 초기화&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;node_t형 포인터 초기화&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// initialize root
    node_t *root = NULL;

    // insert nodes
    insert(&amp;amp;root, 7);
    insert(&amp;amp;root, 3);
    insert(&amp;amp;root, 5);
    insert(&amp;amp;root, 9);
    //     7
    //    / \
    //   3   9
    //  / \  | \
    // N   5 N  N
    //    / \
    //   N   N
    print_tree(root);&lt;/code&gt;&lt;/pre&gt;&lt;h2&gt;functions&lt;/h2&gt;
&lt;h3&gt;int print_tree(node_t *curr) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;트리의 모든 노드의 key값을 오름차순으로 출력하는 함수&lt;/li&gt;
&lt;li&gt;recursion을 이용한 dfs&lt;/li&gt;
&lt;li&gt;left subtree 탐색 -&amp;gt; 현재 노드 출력 -&amp;gt; right subtree 탐색 순서&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// print keys of tree in increasing order
// using dfs
int print_tree(node_t *curr){

    // base case:
    if (curr == NULL) return 0;

    // recursive call: dfs
    print_tree(curr-&amp;gt;left);
    printf(&amp;quot;%d\n&amp;quot;, curr-&amp;gt;key);
    print_tree(curr-&amp;gt;right);

    return 0;
}&lt;/code&gt;&lt;/pre&gt;&lt;h2&gt;node_t *search(node_t *curr, int k) 함수&lt;/h2&gt;
&lt;ul&gt;
&lt;li&gt;주어진 key값을 가지는 노드를 찾아 그 주소(포인터) 반환하는 함수&lt;/li&gt;
&lt;li&gt;recursion을 이용한 탐색&lt;/li&gt;
&lt;li&gt;주어진 key값과 노드의 key값을 비교해서 left child/ right child 노드로 이동&lt;/li&gt;
&lt;li&gt;마지막 노드로 갔을때(주어진 key값이 없을 때)와 주어진 key값을 찾을 찾았을 때 탐색 종료&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// find and return the address(node_t * type) of target node
// recursive version
node_t *search(node_t *curr, int k){
    // base case1: end of tree: return NULL
    if (curr == NULL){
        printf(&amp;quot;cannot find a node with value %d !!\n&amp;quot;, k);
        return curr;
    }
    // base case2: find target node
    if (curr-&amp;gt;key == k) return curr;

    // target과 현재 노드의 key를 대소비교하며 찾아 내려간다
    // search left-subtree
    if (k &amp;lt; curr-&amp;gt;key) return search(curr-&amp;gt;left, k);
    // search right-subtree
    else return search(curr-&amp;gt;right, k);
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;node_t *search_iterative(node_t *curr, int k) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;바로 위 search 함수의 iterative 버전&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// find and return the address(node_t * type) of target node
// iterative version
node_t *search_iterative(node_t *curr, int k){
    // move to child node
    while (curr != NULL &amp;amp;&amp;amp; curr-&amp;gt;key != k){
        // search left-subtree
        if (k &amp;lt; curr-&amp;gt;key) curr = curr-&amp;gt;left;
        // search right-subtree
        else curr = curr-&amp;gt;right;
    }
    // end of tree
    if (curr == NULL){
        printf(&amp;quot;cannot find a node with value %d !!\n&amp;quot;, k);
    }
    return curr;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;node_t * minimum(node_t *curr) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;트리에서 최소 key값을 가지는 노드의 주소(포인터)를 반환하는 함수&lt;/li&gt;
&lt;li&gt;트리에서 가장 왼쪽에 있는 노드를 반환&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// find minimum key in tree
node_t * minimum(node_t *curr){
    // move to most-left-outside node
    while (curr-&amp;gt;left != NULL) curr = curr-&amp;gt;left;
    return curr;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;node_t *maximum(node_t *curr) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;트리에서 최대 key값을 가지는 노드의 주소(포인터)를 반환하는 함수&lt;/li&gt;
&lt;li&gt;트리에서 가장 오른쪽에 있는 노드를 반환&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// find maximum key in tree
node_t *maximum(node_t *curr){
    // move to most-right-outside node
    while (curr-&amp;gt;right != NULL) curr = curr-&amp;gt;right;
    return curr;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;node_t *successor(node_t *curr) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;주어진 노드의 successor 노드의 주소(포인터)를 반환하는 함수&lt;/li&gt;
&lt;li&gt;successor: 노드의 key들을 오름차순 정렬했을때 바로 다음에 오는 key값을 가지는 노드&lt;/li&gt;
&lt;li&gt;case1, 오른쪽 subtree가 비지 않았을 때: 오른쪽 subtree에서의 최소 값을 가지는 노드가 successor&lt;/li&gt;
&lt;li&gt;case2, 오른쪽 subtree가 비었을 때, curr의 조상 중 처음으로 left-child가 되는 노드의 부모 노드가 successor&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// return the successor of given node
// successor: 주어진 노드의 key 바로 다음에 오는 key값을 가진 node
node_t *successor(node_t *curr){
    // case1: right subtree is non-empty
    if (curr-&amp;gt;right != NULL) return minimum(curr-&amp;gt;right);
    // case2: right-subtree is empty
    node_t *temp;
    temp = curr-&amp;gt;parent;
    // 조건을 만족할 때까지 트리를 타고 올라간다
    // 조건: curr의 조상 중 처음으로 left child가 되는 노드의 부모 노드를 찾는다
    while( temp != NULL &amp;amp;&amp;amp; temp-&amp;gt;right == curr){
        curr = temp;
        temp = temp-&amp;gt;parent;
    }
    // check impossible cases(루트노드까지 올라간 경우)
    if (temp == NULL){
        printf(&amp;quot;there is no successor of given node!\n&amp;quot;);
    }
    return temp;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;node_t *predecessor(node_t *curr) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;주어진 노드의 predecessor 노드의 주소(포인터)를 반환하는 함수&lt;/li&gt;
&lt;li&gt;predecessor: 노드의 key들을 오름차순 정렬했을 때 직전에 오는 key값을 가지는 노드&lt;/li&gt;
&lt;li&gt;successor함수와 거울 대칭으로 탐색&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// 참고:successor함수와 대칭
// return the predecessor of given node
// predecessor: 주어진 노드의 key 직전에 오는 key값을 가진 node
node_t *predecessor(node_t *curr){
    // case1: left-subtree is non-empty
    if (curr-&amp;gt;left != NULL) return maximum(curr-&amp;gt;left);
    // case2: left-subtree is empty
    node_t *temp;
    temp = curr-&amp;gt;parent;
    // 조건을 만족할 때까지 트리를 타고 올라간다
    // 조건: curr의 조상 중 처음으로 right-child가 되는 노드의 부모를 찾는다
    while(temp != NULL &amp;amp;&amp;amp; temp-&amp;gt;left == curr){
        curr = temp;
        temp = temp-&amp;gt;parent;
    }
    // check impossible cases
    if (temp == NULL){
        printf(&amp;quot;there is no successor of given node!\n&amp;quot;);
    }
    return temp;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;int insert(node_t **ptr_root, int k) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;트리에 주어진 key값을 가지는 새로운 노드를 추가하는 함수&lt;/li&gt;
&lt;li&gt;예외: 트리가 비었을 경우 새로운 노드를 root노드로 설정&lt;/li&gt;
&lt;li&gt;주어진 key값과 현재 노드의 key값을 대소비교하면서 트리를 타고 내려간다&lt;/li&gt;
&lt;li&gt;leaf node에 도달하면 여기에 새로운 노드를 자식 노드로 추가&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// 주어진 값을 갖는 노드 추가
int insert(node_t **ptr_root, int k){
    // make new_node with key k
    node_t * new_node = (node_t*)malloc(sizeof(node_t));
    new_node-&amp;gt;key = k;
    new_node-&amp;gt;parent = NULL;
    new_node-&amp;gt;left = NULL;
    new_node-&amp;gt;right = NULL;

    // check tree is empty: make root points to new node
    if (*ptr_root == NULL){
        *ptr_root = new_node;
        return 0;
    }
    // 대소비교하면서 leaf node까지 내려간다
    node_t *curr = *ptr_root;    // root부터 시작
    node_t *before = NULL;       // x 직전 node기록하기 위함
    while (curr != NULL){        // before이 new_node의 부모가 될 노드
        before = curr;
        if (k &amp;lt; curr-&amp;gt;key) curr = curr-&amp;gt;left;
        else curr = curr-&amp;gt;right;
    }
    // curr == NULL 이면 before은 마지막 leaf node
    // before node 밑에 new_node 추가
    new_node-&amp;gt;parent = before;
    if (k &amp;lt; before-&amp;gt;key) before-&amp;gt;left = new_node;
    else before-&amp;gt;right = new_node;

    return 1;
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;void delete(node_t **ptr_root, node_t *target) 함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;트리에서 주어진 노드를 삭제하는 함수&lt;/li&gt;
&lt;li&gt;3가지 케이스로 나누어 삭제를 진행&lt;/li&gt;
&lt;li&gt;case1, target node의 자식 노드가 0개: target node 제거하고 그 위치에 NULL 추가&lt;/li&gt;
&lt;li&gt;case2, target node의 자식 노드가 1개: target node 제거 후 target node의 부모에 target node의 자식 노드 연결&lt;/li&gt;
&lt;li&gt;case3, target node의 자식 노드가 2개: target node와 그 successor의 key값을 교환하고, successor node를 제거(successor노드의 부모노드와 successor노드의 자식노드를 연결)&lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// target 노드의 주소값을 받아 트리에서 제거
void delete(node_t **ptr_root, node_t *target){

    // introduction to algorithms 책 보고 이해하는 것 추천

    ////////////////////////
    // 1. splice 대상 y 결정

    node_t *y = NULL;
    // target의 자식 노드가 0, 1개인 경우: splice 대상 y는 target 자신
    if (target-&amp;gt;left == NULL || target-&amp;gt;right ==NULL) y = target;
    // target의 자식 노드가 2개인 경우: splice 대상 y는 target 노드의 successor 노드
    else y = successor(target);

    /////////////////////////
    // 2. y의 자식 노드 x 결정
    // y가 잘려나가면 그 밑의 노드를 이어주어야 하므로

    node_t *x = NULL;
    if (y-&amp;gt;left != NULL) x = y-&amp;gt;left;
    else x = y-&amp;gt;right;

    /////////////////////////
    // 3. splicing y

    // exception case1: x = NULL인 경우 제외
    if (x != NULL) x-&amp;gt;parent = y-&amp;gt;parent;
    // exception case2: y가 root node인 경우(y-&amp;gt;parent == NULL)
    if (y-&amp;gt;parent == NULL) *ptr_root = x;
    // y가 root node가 아닌 경우
    else {
        // y의 위치에 따라 x의 부모를 y의 부모로 설정
        if (y-&amp;gt;parent-&amp;gt;left == y) y-&amp;gt;parent-&amp;gt;left = x;
        else y-&amp;gt;parent-&amp;gt;right = x;
    }
    // target의 자식이 2개인 경우: splicing 대상 y는 target이 아니라 target의 successor
    if (y != target) target-&amp;gt;key = y-&amp;gt;key;
    // delete y
    free(y);
}&lt;/code&gt;&lt;/pre&gt;</description>
      <category>dev/C lang</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/20</guid>
      <comments>https://blog.realbro.dev/20#entry20comment</comments>
      <pubDate>Sun, 5 Sep 2021 23:31:29 +0900</pubDate>
    </item>
    <item>
      <title>(c lang) linked-list 구현</title>
      <link>https://blog.realbro.dev/19</link>
      <description>&lt;h2&gt;연결리스트 구현&lt;/h2&gt;
&lt;h3&gt;노드 구현(node_t형 구조체)&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;노드 구조체는 int 형 val멤버와 다음 노드를 가리키는 node_t형 포인터 next멤버를 갖는다&lt;pre&gt;&lt;code&gt;// node definition
typedef struct node{
  int val;
  struct node *next;
} node_t&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;linked-list 초기화&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;node_t *head = NULL;&lt;/li&gt;
&lt;li&gt;node_t형 포인터로 초기화&lt;pre&gt;&lt;code&gt;// initialize head(node_t pointer)
node_t * head = NULL;&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;print_list함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;print_list(node_t *head);&lt;/li&gt;
&lt;li&gt;첫 노드부터 마지막 노드까지 val 멤버를 출력&lt;/li&gt;
&lt;li&gt;예외1: 노드가 없는 경우&lt;pre&gt;&lt;code&gt;// print out value of all nodes
int print_list(node_t * head){
  node_t *curr = head;
  // exception case: no node
  if (curr == NULL){
      printf(&amp;quot;there is no node!\n&amp;quot;);
      return -1;
  }
  // print until curr node is NULL
  while (curr != NULL){
      printf(&amp;quot;%d &amp;quot;, curr-&amp;gt;val);
      curr = curr-&amp;gt;next;
  }
  printf(&amp;quot;\n&amp;quot;);
  return 1;
}&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;add_last함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;add_last(node_t **ptr_head, int val);&lt;/li&gt;
&lt;li&gt;새 노드 생성 후 연결리스트의 마지막에 첨가&lt;/li&gt;
&lt;li&gt;이중포인터를 인자로 받는 이유: 노드가 없는 경우(head == NULL) head가 가리키는 주소를 새로 할당해야하므로 head의 주소값(&amp;amp;head &amp;lt;-- node_t**형)을 함수 인자로 받는다&lt;/li&gt;
&lt;li&gt;연결리스트의 마지막 노드로 이동하여 마지막 노드가 새로운 노드를 가리키게 한다&lt;/li&gt;
&lt;li&gt;예외1: 노드가 없는 경우 head의 주소값(ptr_head)로 접근해 head의 값을 변경(*ptr_head = new_node) &lt;/li&gt;
&lt;/ul&gt;
&lt;pre&gt;&lt;code&gt;// add node to last of linked-list
void add_last(node_t **ptr_head, int val){
    node_t *curr = *ptr_head;
    // make new node with given value
    node_t *new_node = (node_t *)malloc(sizeof(node_t));
    new_node-&amp;gt;val = val;
    new_node-&amp;gt;next = NULL;

    // exception case: no node --&amp;gt; make head to point new_node
    if (curr == NULL){
        *ptr_head = new_node;
    } 
    else{
        // move to last node
        while (curr-&amp;gt;next != NULL){
            curr = curr-&amp;gt;next;
        }
        // add new node to curr
        curr-&amp;gt;next = new_node;
    }
}&lt;/code&gt;&lt;/pre&gt;&lt;h3&gt;push_head함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;push_head(node_t **ptr_head, int val);&lt;/li&gt;
&lt;li&gt;연결리스트의 맨 앞에 새로운 노드 삽입&lt;/li&gt;
&lt;li&gt;새로운 노드를 생성하고 원래 첫 노드를 가리키게 한다. 그리고 원래의 head가 새로운 노드를 가리키게 한다(head를 바꾸기 위해 &amp;amp;head로 접근: node_t **형을 함수 인자로 받음)&lt;/li&gt;
&lt;li&gt;예외1: 노드가 없는 경우 add_last함수를 실행하면 동일한 효과를 얻는다&lt;pre&gt;&lt;code&gt;// push node in front of linked-list
void push_head(node_t **ptr_head, int val){
  // exception case: no node: just append
  if (*ptr_head == NULL){
      add_last(ptr_head, val);
  }
  else {
      // new_node
      node_t *new_node = (node_t *)malloc(sizeof(node_t));
      new_node-&amp;gt;val = val;
      // head points to new_node and new_node points to node that head pointed to
      new_node-&amp;gt;next = *ptr_head;
      *ptr_head = new_node;
  }
}&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;pop_last함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;pop_last(node_t **ptr_head)&lt;/li&gt;
&lt;li&gt;연결리스트의 마지막 노드를 pop하고 그 값을 반환&lt;/li&gt;
&lt;li&gt;노드가 0개, 1개, 그 이상으로 케이스를 나눔&lt;/li&gt;
&lt;li&gt;노드가 2개 이상일 경우 마지막에서 2번째 노드로 이동하여 마지막 노드 삭제(free로 동적 할당 해제)&lt;pre&gt;&lt;code&gt;// pop last node
int pop_last(node_t **ptr_head){
  int return_val;
  node_t *curr = *ptr_head;
  // exception case1: no node
  if (curr == NULL){
      printf(&amp;quot;there is no node!\n&amp;quot;);
      return -1;
  }
  // exception case2: 1 node
  if (curr-&amp;gt;next == NULL){
      return_val = curr-&amp;gt;val;
      free(curr);
      *ptr_head = NULL;
  } else{
      // move to second last node
      while (curr-&amp;gt;next-&amp;gt;next != NULL){
          curr = curr-&amp;gt;next;
      }
      return_val = curr-&amp;gt;next-&amp;gt;val;
      // delete target node
      free(curr-&amp;gt;next);
      curr-&amp;gt;next = NULL;
  }
  return return_val;
}&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;pop_head함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;pop_head(node_t **ptr_head)&lt;/li&gt;
&lt;li&gt;연결리스트의 첫 노드를 pop하고(동적 할당 해제) 그 값을 반환&lt;/li&gt;
&lt;li&gt;노드가 0개, 1개, 그 이상으로 케이스를 나눔&lt;/li&gt;
&lt;li&gt;노드가 1개일 경우 pop_last함수와 동일한 효과&lt;pre&gt;&lt;code&gt;// pop out head or linked list
int pop_head(node_t **ptr_head){
  int return_val;
  node_t* head = *ptr_head;
  // exception case1: no node
  if (head == NULL){
      printf(&amp;quot;there is no node!&amp;quot;);
      return -1;
  }
  // exception case1: one node
  if (head-&amp;gt;next == NULL){
      return pop_last(ptr_head);
  }
  else{
      // make mead to point second node
      *ptr_head = head-&amp;gt;next;
      return_val = head-&amp;gt;val;
      // delete target node
      free(head);
      return return_val;
  }
}&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;h3&gt;remove_by_index함수&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;remove_by_index(node_t **ptr_head, int idx)&lt;/li&gt;
&lt;li&gt;주어진 idx+1번째 노드를 pop(동적 할당 해제)하고 그 값을 반환&lt;/li&gt;
&lt;li&gt;노드가 0개, 1개, 그 이상으로 케이스를 나눔&lt;/li&gt;
&lt;li&gt;idx-1번째 노드로 이동하여 idx번째 노드 삭제&lt;/li&gt;
&lt;li&gt;idx가 연결리스트의 길이 이상이면 -1 반환&lt;pre&gt;&lt;code&gt;int remove_by_index(node_t **ptr_head, int idx){
  int return_val;
  node_t *curr = *ptr_head;
  // exception case1: no node
  if (curr == NULL){
      printf(&amp;quot;there is no node!&amp;quot;);
      return -1;
  }
  // exception case2: idx == 0
  if (idx == 0){
      return pop_head(ptr_head);
  }
  // move curr to node[idx-1]
  for (int i=0; i&amp;lt;idx-1; i++){
      // check if curr-&amp;gt;next is NULL; check node[idx] is existing
      if (curr-&amp;gt;next == NULL){
          printf(&amp;quot;given index exceed the length of linked-list!\n&amp;quot;);
          return -1;
      }
      curr = curr-&amp;gt;next;
  }
  // target node: node[idx]
  node_t *target = curr-&amp;gt;next;
  // check if target_node is NULL
  if (target == NULL){
      printf(&amp;quot;given index exceed the length of linked-list!\n&amp;quot;);
      return -1;
  }
  return_val = target-&amp;gt;val;
  // make curr(node[idx-1]) to point node([idx+1])
  curr-&amp;gt;next = target-&amp;gt;next;
  // delete target node
  free(target);
  return return_val;
}&lt;/code&gt;&lt;/pre&gt;&lt;/li&gt;
&lt;/ul&gt;</description>
      <category>dev/C lang</category>
      <author>realbro.noh</author>
      <guid isPermaLink="true">https://blog.realbro.dev/19</guid>
      <comments>https://blog.realbro.dev/19#entry19comment</comments>
      <pubDate>Sat, 4 Sep 2021 19:59:40 +0900</pubDate>
    </item>
  </channel>
</rss>