엔지니어는 배가 고프다

최근에 진행한 프로젝트에서 [언리얼 - 임베디드 SW] UDP 통신 구현한 내용 공유

언리얼 C++ 로 하는 방법도 있지만, 블루프린트로 UDP 통신 구현이 필요할 수 도 있음

TCP UDP Socket Client Plugin 구매, 설치

[Blueprint] UDP 초기화

[Blueprint] UDP 전송

[Blueprint] UDP 수신

윈도우 <-> 유닉스 통신이 안될 경우 해결법

본인 IP 로 데이터 전송하고, 콘솔에서 포트포워딩으로 데이터 넘겨주기

참고: https://www.youtube.com/watch?v=tYo6KCmelM8

요약

독서 날짜: 2020.01 (1회독), 2024.08 (2회독)

핵심 내용: 인터넷과 디지털 미디어의 과도한 사용이 사람의 깊이 있는 사고 능력을 약화시키고, 생각하는 방식을 얕고 단편적으로 변화시킴.

세부 내용

문자 혁명과 인간 사고의 확장

문자가 새로운 사고의 도구로 등장함.

책과 문서의 깊이 읽기를 통해 사고가 깊어짐.

이는 인간이 신경 가소성을 가지기 때문에 발생하는 현상.

심지어 이렇게 독서로 인해 얻은 깊이 사고하는 능력이 다른 활동에 긍정적 효과를 주는 것이 연구로 밝혀짐.

인터넷이 뇌 구조를 바꿈

인터넷은 집중력을 분산함.

- 의식/무의식 사고에 합선을 일으켜 깊은 창의적 사고를 방해

- Switching Cost 로 인한 에너지 낭비

인터넷은 지식을 '직접 아는 것'이 아닌 '찾을 수 있는 것' 으로 획득함.

즉, 인터넷은 기억을 아웃 소싱함.

인터넷은 뇌구조를 화학적, 해부학적으로 변화시킴.

결과적으로 인간의 정체성을 인터넷에게 뺏김.

RIP, OSPF 비교

라우팅 기준

홉

이동한 횟수.

예를 들어, A->B->D 는 2 이고, A->B 는 1 임.

링크의 비용

이동할 때 요구되는 비용의 합.

예를 들어, A->B->D 는 2+2=4 이고, A->B 는 2 임.

최적 경로 계산 알고리즘

벨만-포드

해당 위치까지 누적 매트릭(거리)이 낮은 것을 모든 지점에서 정보를 받아서 갱신함.

위 갱신을 모든 경로들에 대하여 차례대로 확인.

경로 확인 순서:

A-B, A-D, B-D, D-C, C-E, C-F, E-F

매트릭: 홉

1: A->D->C

2: A->D->C->F

매트릭: 링크의 비용

1: A->D->C

2: A->D->C->E->F

다익스트라

누적 매트릭(거리)이 낮은 경로 부터 순서 대로 이동함.

만약 해당 경로의 도착지에 먼저 도착한 경로가 있다면, 해당 경로는 제거함.

경로 처리 순서 (괄호 내의 숫자가 처리된 순서)

매트릭: 홉

A->B(1)->D(3) [제거]

A->D(2)->C(4)->E(5)

A->D(2)->C(4)->F(6) [종료]

매트릭: 링크의 비용

A->D(1)->C(3)->E(5)->F(7) [종료]

A->D(1)->C(3)->F(6) 

A->B(2)->D(4) [제거]

알고리즘 예시 코드

벨만-포드 C++ 코드

예시로 아래 문제에 대한 벨만-포드 기반 최단 경로 찾기 C++ 코드를 작성해봤습니다.

https://www.acmicpc.net/problem/1753

#include <iostream>
#include <vector>
using namespace std;
const int INF = 1000000000;

struct Edge {
    int start, target, cost;
};

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int V, E;
    cin >> V >> E;
    int K;
    cin >> K;

    vector<Edge> edges;
    edges.reserve(E);
    for (int i = 0; i < E; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        edges.push_back({ u, v, w });
    }

    vector<int> dist(V + 1, INF);
    dist[K] = 0;

    // V-1번 반복
    for (int i = 1; i <= V - 1; i++) {

        bool updated = false;

        for (auto& e : edges) {
            if (dist[e.start] != INF && dist[e.start] + e.cost < dist[e.target]) {
                dist[e.target] = dist[e.start] + e.cost;
                updated = true;
            }
        }

        if (!updated) {
            break;
        }
    }

    // (음수 사이클 검사 - 필요하면 사용)
    // for (auto &e : edges) {
    //    if (dist[e.u] != INF && dist[e.u] + e.w < dist[e.v]) {
    //        // 음수 사이클 존재
    //    }
    // }

    for (int i = 1; i <= V; i++) {

        if (dist[i] == INF) {
            cout << "INF";
        }
        else {
            cout << dist[i];
        }

        cout << "\n";
    }

    return 0;
}

다익스트라 C++ 코드

동일하게 위 문제에 대한 다익스트라 C++ 코드입니다.

#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int INF = 1000000000;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int V, E;
    cin >> V >> E;
    int K;
    cin >> K;

    vector<vector<pair<int, int>>> graph(V + 1);
    for (int i = 0; i < E; i++) {
        int start, target, cost;
        cin >> start >> target >> cost;
        graph[start].push_back({ target, cost });
    }

    vector<int> dist(V + 1, INF);
    dist[K] = 0;

    priority_queue<pair<int, int>, vector<pair<int, int>>, greater<pair<int, int>>> pq;
    pq.push({ 0, K });

    while (!pq.empty()) {
        
        auto [cost, u] = pq.top();
        pq.pop();

        if (cost > dist[u]) {
            continue;
        }

        for (auto& edge : graph[u]) {
            
            int v = edge.first;
            int w = edge.second;
            
            if (dist[v] > dist[u] + w) {
                dist[v] = dist[u] + w;
                pq.push({ dist[v], v });
            }
        }
    }

    for (int i = 1; i <= V; i++) {
        
        if (dist[i] == INF) {
            cout << "INF";
        }
        else {
            cout << dist[i];
        }

        cout << '\n';
    }

    return 0;
}

범용 게이트

: 어떤 논리 회로든 단독으로 구현할 수 있는 논리 게이트

  대표적으로 NAND 게이트와 NOR 게이트가 있음

회로도

게이트별 트렌지스터 개수

( 표준 CMOS 기준, 2입력 게이트)

: 범용 게이트 NAND, NOR 가 AND, OR 보다 트렌지스터 수가 적다.

  따라서  

과거 마이크로 프로세서

: 초기 IC(집적회로)는 트랜지스터 수가 수십~수백 개 수준이므로 가능한 한 단순해야 했음 

  여러 가지 게이트를 따로 제작하면 공정이 복잡해지고 원가↑, 수율↓

  따라서 한 종류의 게이트 (범용 게이트) 만 사용한 경우 많았

현대 마이크로 프로세서

: 과거보다 효율성을 더 추구하여 아래와 같은 필요에 따라 다양한 게이트 사용함

• 트랜지스터 수 최소화
  • NAND/NOR만 쓰면 불필요하게 게이트 수가 늘어날 수 있음.
  • 예: 단순 NOT을 NAND로 만들면 트랜지스터 4개 필요 → 그냥 인버터 쓰면 2개로 구현 가능
• 속도 최적화
  • CMOS에서 게이트 지연(delay)은 트랜지스터 직렬·병렬 수에 크게 좌우됨.
  • 따라서 특정 논리를 NAND만으로 표현하면 불필요하게 깊은 게이트 체인이 생김 → 지연 ↑
• 소비전력과 면적 최적화
  • 전력은 게이트 수와 배선 길이에 비례.
  • 설계자는 라이브러리에서 가장 효율적인 “표준 셀(standard cell)”을 골라 씀.
  • 표준 셀 라이브러리는 NAND, NOR, INV, XOR, MUX 등 다양한 기본 게이트를 포함.
• 특수 연산
  • CPU ALU에는 XOR, MUX, AOI (AND-OR-Invert), OAI (OR-AND-Invert) 같은 복합 게이트가 자주 쓰임.
  • 이런 게이트는 단순 NAND 조합보다 속도·면적 최적화가 잘 됨.

분류

• 데이터 분포를 학습하여 샘플을 생성하는 확률 생성 모델 (probabilistic generative model)

정의

• 데이터를 점차적으로 노이즈화하는 forward process와, 원래 데이터를 복원하는 reverse denoising process로 구성된 확률 기반 생성 모델

특징

• 수학적으로 Markov Process에 기반한 연속적 상태 변화 모델
• 실제 학습 시에는 신경망을 사용해 reverse process를 근사
• Stable Diffusion, Imagen (Google), DALLE-2 (GPT) 등의 모델이 diffusion 을 기반으로 함

아래의 문제에 대하여 C++ 의 해쉬에 해당하는 unordered map 과 array 로 구현했을 때, 속도 비교를 하고자 합니다

최빈값 문제는 다음과 같습니다

Array 기반으로 해결하는 방법의 코드입니다

#include <string>
#include <vector>

using namespace std;

int solution(vector<int> array) {
    int array_list[1000] = {0,};
    int max = 0;
    int out = -1;
    for (int i = 0; i < array.size(); i++) {
        array_list[array[i]] += 1;
        if (array_list[array[i]] > max) {
            max = array_list[array[i]];
            out = array[i];
        } else if (array_list[array[i]] == max) {
            out = -1;
        }
    }
    return out;
}

Hash 기반으로 해결하는 다른 분의 코드입니다.

#include <string>
#include <vector>
#include <unordered_map>
using namespace std;

int solution(vector<int> array) {
    int answer = 0;
    int maxV = 0;

    unordered_map<int,int> um;
    for(const auto v : array)
    {
        um[v]++;
    }

    for(const auto& v : um)
    {
        if(v.second > maxV)
        {
            maxV = v.second;
            answer = v.first;
        }
        else if(v.second == maxV)
        {
            answer = -1;
        }
    }

    return answer;
}

실행결과: 특정 데이터에서 Hash 기반 구현이 Array 기반 구현보다 느린 것을 확인할 수 있습니다