임베디드

xfce4에서 super L키 동작시키기

수리노을 — Fri, 9 Dec 2022 18:58:01 +0900

1. xfce4 setting manager 실행

2. https://www.linuxhelp.com/how-to-install-xfdashboard-in-ubuntu (xfdashboard 설치)

3. super+L키에 shortcut으로 등록

Happy Birthday Linux from 유영재

수리노을 — Sun, 16 Aug 2020 21:26:26 +0900

Happy Birthday Linux !!!

블로그 이전을 준비 중입니다

수리노을 — Fri, 22 Nov 2019 08:05:28 +0900

github page로 블로그 이전을 준비하고 있습니다. 총 2가지 이유입니다.

1. 최근 면접을 통해 포트폴리오의 중요성을 깊게 깨달았습니다. 따라서 깃헙을 통한 포트폴리오 + 개발 두 가지를 모두 잡기 위해서 시작할 것 같습니다

2. 사용자 url로 전환이 가능해 추후 저만의 웹 사이트를 구축 가능

지킬 생성기 기반의 페이지를 가져갈 것이고 구축하고 익숙해지는데 시간이 소요될 것 같습니다. 그 전까지는 블로그 게시는 없을 것 같습니다

컴파일 에러와 런타임 에러

수리노을 — Mon, 18 Nov 2019 15:07:33 +0900

[참고] https://spaghetti-code.tistory.com/35

#include <stdio.h>

int main(void) {
	void* ptr = NULL;
	int a = 3;
	ptr = &a;
	printf("%d\n", *ptr);
}

위 에러는 '식이 완전한 개체 형식의 포인터여야 합니다'라고 컴파일 오류를 낸다. '타입체크 에러'로 분류되는 것 같다

[수정 후]

#include <stdio.h>

int main(void) {
	void* ptr = NULL;
	int a = 3;
	ptr = &a;
	printf("%d\n", *(int*)ptr);
}

할당되지 않는 영역에 대해서 읽기를 시도할 때는 런타임 에러를 발생시킨다

#include <stdio.h>

int main(void) {
	printf("%d\n", *(int*)(0x0A0A));
	return 0;
}

for문 증감부분에서의 ++i와 i++의 차이

수리노을 — Sun, 17 Nov 2019 11:51:10 +0900

i++, ++i 증감연산자를 하면 실제로 연산자 오버로딩으로 들어가게 된다

https://docs.microsoft.com/ko-kr/cpp/cpp/increment-and-decrement-operator-overloading-cpp?view=vs-2019

전위 증가연산자는 자신의 객체가 그대로 반환되도 되기 때문에 빠르지만, 후위 증가연산자는 다음 행에서 변화가 생겨야하므로 객체를 복사하는 부분이 따로 이뤄지기 때문에 전위연산자를 다시 한 번 호출하기 때문에 조금 느리다. 하지만 큰 차이는 없는 것 같다

friend 함수, 클래스 올바르게 사용하기

수리노을 — Sun, 17 Nov 2019 11:45:56 +0900

클래스 간 상호작용을 위해서 friend 키워드가 가끔 사용된다. 캡슐화에 위배되는 사항이라 사용은 지양되지만 실제로 연산자 오버로딩 등 절대적으로 필요한 부분이 있다

다음 코드는 클래스 A에 private 멤버에 접근하려고하니 오류가 발생한 것이다

#include <iostream>

using namespace std;

class A {
private:
	int m_value = 1;
};

void printA(A &a) {
	cout << a.m_value << '\n'; // 컴파일 오류
}

int main(void) {
	A a;
	printA(a);
	return 0;
}

friend 함수를 정의해서 'printA는 우리와 친구다'라고 A class 안에서 정의할 수 있다

#include <iostream>

using namespace std;

class A {
private:
	int m_value = 1;

	friend void printA(A &);
};

void printA(A &a) {
	cout << a.m_value << '\n';
}

int main(void) {
	A a;
	printA(a);
	return 0;
}

클래스 하나를 더 확장을 해보자. 그런데 다시 a.m_value 쪽에서 오류가 발생한다

#include <iostream>

using namespace std;

class A {
private:
	int m_value = 1;

	friend void printA(A &, B &);
};

class B {
private:
	int m_value = 2;

	friend void printA(A &, B &);
};

void printA(A &a, B &b) {
	// a.m_value만 오류
	cout << a.m_value << ' ' << b.m_value << '\n'; 
}

int main(void) {
	A a;
	B b;
	printA(a, b);
	return 0;
}

이유는 class A는 class B 앞에 선언되어 있기 때문에 B의 존재를 알 수가 없기에 식별자 오류를 발생시켰다. 따라서 함수 프로토타입처럼 전방선언을 해줘야만 A는 B의 존재를 이때서야 알게 된다

class B;
class A {
	...
};

friend class는 다음과 같이 클래스를 friend 선언을 통해서 나타낸다

#include <iostream>

using namespace std;

class B;
class A {
private:
	int m_value = 1;

	friend class B;
};

class B {
private:
	int m_value = 2;

public:
	void doSomething(A &a) {
		cout << a.m_value << '\n';
	}
};

int main(void) {
	A a;
	B b;
	b.doSomething(a);
	return 0;
}

그리고 클래스 전방 선언을 할지라도 그 안의 멤버함수와, 변수의 내용은 알지 못한다.

아래 코드에서는 class B를 알지만, doSomething이라는 멤버함수가 있는지까지는 모른다

#include <iostream>

using namespace std;

class B;
class A {
private:
	int m_value = 1;

	friend void B::doSomething(A &a);
};

class B {
private:
	int m_value = 2;

public:
	void doSomething(A &a) {
		cout << a.m_value << '\n';
	}
};

그러면 class B를 올려볼까?

#include <iostream>

using namespace std;

class A;
class B {
private:
	int m_value = 2;

public:
	void doSomething(A &a) {
		cout << a.m_value << '\n';
	}
};

class A {
private:
	int m_value = 1;

	friend void B::doSomething(A &a);
};

그래도 오류가 발생한다. 왜냐하면 이제는 class A가 전방선언이 되어있다고 하지만, A의 멤버변수인 m_value에 대해서는 알지 못한다. 따라서 보통 이러한 경우에는 class A, B가 모두 선언된 후 밑에다 작성을 해야만 한다

#include <iostream>

using namespace std;

class A;
class B {
private:
	int m_value = 2;

public:
	void doSomething(A &);
};

class A {
private:
	int m_value = 1;

	friend void B::doSomething(A &a);
};

void B::doSomething(A &a) {
	cout << a.m_value << '\n';
}

int main(void) {
	A a;
	B b;
	b.doSomething(a);
	return 0;
}

[수정 전] Makefile 작성하기

수리노을 — Sat, 16 Nov 2019 23:52:49 +0900

LRU Cache의 자료구조

수리노을 — Sat, 16 Nov 2019 21:30:03 +0900

페이지 교체 알고리즘 중 하나로 가장 hit율이 좋다고 알려진 LRU는 Least Recently Used의 약자로 가장 늦게 쓰여진 페이지가 교체 대상이 되는 것이다

자료구조는 map을 원소로 하는 리스트 기반으로 이뤄져 있다

[참고] https://www.geeksforgeeks.org/lru-cache-implementation/

new 연산자를 이용한 2차원 배열 할당

수리노을 — Sat, 16 Nov 2019 15:31:06 +0900

malloc과 비슷하게 먼저 각 행에 대한 base 주소를 할당하고 주소 하나당 열에 맞춰서 크기를 할당해서 2차원 배열을 만들 수 있다. new의 장점은 할당을 하면서 초깃값을 정할 수 있다는 점이다

#include <iostream>

using namespace std;

int main(void) {
	int **ptr = new int*[3];
	for (int i = 0; i < 3; i++) {
		ptr[i] = new int[5]{ 1, 2, 3, 4, 5 };
	}

	for (int i = 0; i < 3; i++) {
		for (int j = 0; j < 5; j++) {
			cout << ptr[i][j] << ' ';
		}
		cout << '\n';
	}
	cout << '\n';

	return 0;
}

가상 소멸자가 필요한 이유

수리노을 — Sat, 16 Nov 2019 14:30:04 +0900

다형성에서 주로 거론이 된다. 주로 자식 클래스인 derived는 누구에게서 만들어졌는지 종종 모를 때가 많다. 따라서 base 클래스의 포인터를 선언해서 자식 클래스를 지정해서 삭제하는 경우가 대부분이다

#include <iostream>

using namespace std;

class Base {
public:
	~Base() {
		cout << "Base destructor\n";
	}
};

class Derived : public Base {
private:
	int *arr;

public:
	Derived(int len) {
		arr = new int[len];
	}
	
	~Derived() {
		cout << "Derived destructor\n";
		delete[] arr;
	}
};

int main(void) {
	Derived *d = new Derived(100);
	Base *b = d;

	delete b;
	return 0;
}

Derived destructor가 먼저 호출되어야 하지만 엉뚱하게 Base destructor만 호출됨을 볼 수 있다. 이를 해결하기 위해서는 virtual키워드를 소멸자 앞에 붙여야만 한다

#include <iostream>

using namespace std;

class Base {
public:
	virtual ~Base() {
		cout << "Base destructor\n";
	}
};

class Derived : public Base {
private:
	int *arr;

public:
	Derived(int len) {
		arr = new int[len];
	}
	
	virtual ~Derived() {
		cout << "Derived destructor\n";
		delete[] arr;
	}
};

int main(void) {
	Derived *d = new Derived(100);
	Base *b = d;

	delete b;
	return 0;
}

11^n 이항정리로 구하기

수리노을 — Sat, 16 Nov 2019 04:02:59 +0900

파스칼의 삼각형을 이용하면 이항계수를 쉽게 구할 수 있다. 쉽게 구한 이항계수를 통해서 11^n도 이항정리로 해결할 수 있는데 풀이는 다음과 같다

2004 조합 0의 개수

수리노을 — Fri, 15 Nov 2019 23:16:34 +0900

끝자리에 있는 연속된 0의 개수를 찾는 문제다. 0이 나온다는 것은 10이 곱해졌는 얘기고, 10을 소인수분해하면 2, 5의 인수가 나오기 때문에 2, 5 중 최소 개수를 찾으면 된다

N 제한이 20억이기 때문에 20억을 모두 탐색하면서 나머지 연산을 할 수는 없다

빠르게 2, 5의 개수를 찾는 방법

[참고] https://ksj14.tistory.com/entry/BackJoon1676-%ED%8C%A9%ED%86%A0%EB%A6%AC%EC%96%BC-0%EC%9D%98-%EA%B0%9C%EC%88%98

따라서 조합은 nCr = n! / ((n-r)!*r!) 이므로 각 값에 해당하는 2, 5의 개수를 각각 배열에 담아서 저장해서 마지막에 계산하면 된다. 분자와 분모는 -관계이기 때문에 빼주면서 최소값을 찾으면 된다

문제: https://www.acmicpc.net/problem/2004

깃허브주소: https://github.com/surinoel/boj/blob/master/2004.cpp

17299 오등큰수

수리노을 — Fri, 15 Nov 2019 19:07:24 +0900

오른쪽에 있는 수 중 가장 왼쪽에 있는 큰 수를 확인하는 것이기 때문에

오른쪽부터 탐색을 하면서 왼쪽이 우선이 되어야하므로 스택이라는 자료구조를 사용해야 한다

다만 횟수, 숫자 총 두 가지 정보를 확인해야므로 pair로 stack의 기본 자료형을 정한다

스택에서 뺀다는 의미는 결국, 자신의 왼쪽에 있는 수 기준으로도 자신이 들어갈 것이기 때문에 가장 큰 수라는 것을 알 수 있다

문제: https://www.acmicpc.net/problem/17299

깃허브주소: https://github.com/surinoel/boj/blob/master/17299.cpp

큐 연결리스트로 구현하기

수리노을 — Fri, 15 Nov 2019 16:45:20 +0900

포인터를 이용해 동적할당을 완전히 이해한 예제

영역을 할당받을 때는 매개변수로 전달할 때는 포인터 변수도 복사가 되기 때문에 포인터 변수의 주소를 넘기거나 할당된 영역을 반환받는 함수로 짜야한다

[참고] https://www.geeksforgeeks.org/queue-linked-list-implementation/

포인터로 매개변수 넘겨서 메모리 할당 시 주의할 점

수리노을 — Fri, 15 Nov 2019 02:29:33 +0900

대표적으로 연결리스트 구조로 큐를 만드려고 할 때, 보통 ref 코드를 보면 주소값을 반환하는 init 함수를 만들어서 할당하는 경우들이 대부분이다. 아래와 같이 말이다. 그러면 매개변수로 포인터 변수를 넘겨서도 가능하지 않나?

struct QNode* newNode(int k) 
{ 
    struct QNode* temp = (struct QNode*)malloc(sizeof(struct QNode)); 
    temp->key = k; 
    temp->next = NULL; 
    return temp; 
} 

void enQueue(struct Queue* q, int k) 
{ 
    // Create a new LL node 
    struct QNode* temp = newNode(k); 
    
    ....
}

가능은 하지만 주의할 점이 있다. C언어에서는 같은 레벨의 변수를 넘긴다면 복사해버린다. 즉 같은 레벨을 넘기다보니 실제로 스택에는 똑같은 변수들이 복사되어서 쌓이고 그 함수가 끝나면 사라져버리는 괴이한 현상을 보곤했다. 우리는 이 문제를 해결하기 위해서 포인터를 배웠고, 변경된 값을 받고 싶다면 주소값을 매개변수로 전달했다. 즉 포인터변수 레벨에서도 같은 포인터변수로 매개변수를 받는다면 복사가 이뤄지기 때문에 실제로는 엉뚱한 곳에 할당이 될 것이다

첫번째 코드는 Queue를 정적할당해서 주소값을 전달해 초기화하는 과정이다

두번째 코드는 Queue를 포인터변수로 선언해서 초기화하는 과정이다

따라서 2번의 과정처럼 매개변수 전달이 귀찮다면 주소값을 반환하는 함수를 만들어서 할당하는 것이 맞고, 일반적으로 ref 코드에서 많이 사용되는 것 같다

스택 연결리스트로 구현하기

수리노을 — Fri, 15 Nov 2019 00:57:37 +0900

struct node *top으로 스택의 top으로 지정해서 malloc, free로 노드를 생성하고 삭제할 수 있다

[참고] https://www.tutorialspoint.com/cplusplus-program-to-implement-stack-using-linked-list

C++ 위임생성자

수리노을 — Thu, 14 Nov 2019 15:05:55 +0900

다른 생성자를 호출해서 사용하는 생성자를 위임생성자라고 한다

[참고] http://www.qaupot.com/wordpress/?p=2385

다만 위임 생성자로 초기화를 한다면, 다른 변수에 대해서는 initialize member를 사용할 수 없다. 따라서 중괄호 내부에서 this를 사용해서 초기화를 마쳐야만 한다

17837 새로운 게임 2

수리노을 — Thu, 14 Nov 2019 14:26:37 +0900

새로운 게임 1에서 가장 밑에 있는 말 말고도 전체적인 말이 움직일 수 있는 기회가 주어지게 된다. 따라서 조건이 달라지게 되는데, 새로운 게임 1에서는 턴을 다 돌고나서 마지막에만 점검했는데 이 문제는 턴 과정에서도 4개 이상의 말이 쌓이면 답이 된다. 만일 이 조건에 대해서 검사하지 않았다면 마지막 예제에 대해서 7이라는 값이 도출될 것이다

다음 좌표가 범위를 벗어난다면 {

파란색 타일

}

아니라면 {

if(흰 타일)

else if(빨간 타일)

else if(파란 타일)

}

로 로직을 구분해서 구성했다

문제: https://www.acmicpc.net/problem/17837

깃허브주소: https://github.com/surinoel/boj/blob/master/17837.cpp

함수포인터

수리노을 — Wed, 13 Nov 2019 23:49:02 +0900

함수포인터는 함수의 주소를 담는 변수로 다음과 같이 쓰인다

#include <stdio.h>

void func(int a) {
    printf("value of a is %d\n", a);
}

int main(void) {
    void (*p)(int);
    p = func;
    p(3);

    void (*q)(int) = &func;
    (*q)(4);
    return 0;
}

q를 선언해서 사용할 때 &를 지워서 사용할 수 있다. 함수의 이름은 즉 함수의 주소를 가리키기도 한다

#include <stdio.h>

void func(int a) {
    printf("value of a is %d\n", a);
}

int main(void) {
    void (*p)(int);
    p = func;
    p(3);

    void (*q)(int) = func;
    q(4);
    return 0;
}

함수 포인터 배열을 만들어서 사용할 수 있다. (*p[])로 선언할 수 있다

#include <stdio.h>

void add(int a, int b) {
    printf("add %d+%d=%d\n", a, b, a+b);
}

void sub(int a, int b) {
    printf("sub %d-%d=%d\n", a, b, a-b);
}

void mult(int a, int b) {
    printf("mult %d*%d=%d\n", a, b, a*b);
}

int main(void) {
    void (*op[])(int, int) = { add, sub, mult };
    
    int a = 15, b = 10;
    printf("choose op add 0, sub 1, mult 2\n");
    
    int opt;
    scanf("%d", &opt);
    
    (op[opt])(a, b);  
    
    return 0;
}

함수포인터가 쓰이는 경우

수리노을 — Wed, 13 Nov 2019 21:16:35 +0900

함수포인터는 함수의 주소를 가리키는 포인터다. 일반적으로 다음과 같을 때 사용한다

반환형과 매개변수가 같은 함수의 주소를 가리키게 된다

#include <stdio.h>
#include <stdlib.h>

typedef struct hello {
   void (*print_hello)(void); 
} Hello;

void hello(void) {
    printf("hello world\n");
}

int main(void) {
    Hello *h = (Hello *)malloc(sizeof(Hello));
    h->print_hello = hello;
    h->print_hello();
    return 0;
}

보통 C언어는 객체지향 문법을 지원하지 않는다고 알려져 있다. 하지만 C언어에서도 구조체와 함수 포인터를 활용하면 충분히 객체지향으로 프로그래밍을 할 수 있다. 다음은 리눅스 커널에서 함수 포인터로 객체지향을 구현한 코드다.

[출처] https://dojang.io/mod/page/view.php?id=598

시스템 콜을 함수포인터로 접근하는 예제다

포인터 배열과 배열 포인터

수리노을 — Wed, 13 Nov 2019 16:23:11 +0900

포인터 배열과 배열 포인터은 비슷한 느낌을 주지만 분명히 다른 표현이다

선언 자체에서 다른데, 포인터 배열은 포인터가 여러 개 포함된 배열을 의미한다. 배열 포인터는 배열을 지칭하는 포인터로 보면 된다

포인터 배열은 int *p[3]과 같이 int *p[0], int *p[1], int *p[2] int형 자료형의 주소를 가리킬 수 있는 포인터 변수가 3개 있는 것을 알 수 있다. 배열 포인터는 포인터 배열과 선언이 유사한데 소괄호를 붙인다는 점에서 다르다. 즉 int (*p)[3]처럼 선언을 하는데 이는 int 형 배열의 크기를 3을 갖는 배열의 시작 주소를 가리키게 된다

signed 자료형에서의 비트 반전

수리노을 — Wed, 13 Nov 2019 15:26:49 +0900

signed char 값의 범위는 -128 ~ 127이다

비트 반전 ~ 연산자를 signed char에 씌우면 값은 어떻게 변하게 될까

0 ~ 127은 부호가 반전이 되면서 1이 더해진 값이 반전된 값으로 된다

-1 ~ -128도 부호가 반전이 되지만 1이 빼진 값이 반전된 값으로 된다

#include <stdio.h>

int main(void)
{
    char num = 10;
    printf("not num = %d\n", ~num);

    return 0;
}

17836 공주님을 구해라!

수리노을 — Wed, 13 Nov 2019 01:07:15 +0900

bfs문제로 검을 얻었을 때와 얻지 않았을 때의 최소거리를 구분해줘서 마지막 답에서 비교해서 최소값만 구하면 된다

문제: https://www.acmicpc.net/problem/17836

깃허브주소: https://github.com/surinoel/boj/blob/master/17836.cpp

vim 여러 줄 주석하기

수리노을 — Tue, 12 Nov 2019 11:57:22 +0900

여러 특정 줄을 주석하는 주석하는 방법은 여러가지가 있다

1. esc모드에서 다음과 같이 설정할 수 있다

:s/^/\/\/
:s/^/#
:시작행,끝행/^/#

2. [참고] https://www.youtube.com/watch?v=CRgbuVx59dY

1) ctrl + V로 주석을 하고 싶은 행을 정한다, 화살표 혹은 j, k로 움직인다

2) shift + I를 누르면 블록을 잡은 것을 맨 앞 행으로 움직인다

3) insert 모드로 진입할텐데 자신이 원하는 주석 문자를 쓴다. 예를 들어 //, #

4) 그리고 esc를 누르면 잡았던 블럭에 문자가 생긴다

반대로 주석을 지우는 방법은

1) ctrl + V로 주석을 지우고 싶은 행을 정한다, 화살표 혹은 j, k로 움직인다

2) 그리고 x를 눌러 삭제를 한다

malloc/free와 new/delete 차이

수리노을 — Tue, 12 Nov 2019 11:43:30 +0900

malloc/free와 new/delete의 공통점은 heap 영역에 메모리를 할당하고 해제하는 함수다

기본적으로 태생을 살펴보면 malloc/free는 glibc 라이브러리 함수다

하지만 new/delete는 특정 헤더파일 안에서 동작하는 함수가 아니라 기본적으로 C++ 언어에서 제공되는 연산자다

둘의 가장 큰 차이점은 malloc/free는 클래스의 생성자/소멸자를 호출하지 못하지만, new/delete는 호출한다는 점이다

new/delete로 생성하면 생성자/소멸자가 모두 호출되는 점을 알 수 있다

#include <cstdlib>
#include <iostream>

using namespace std;

class A {
private:
    int num;

public:
    A() {
        num = 3;
        cout << "hello world\n";
    }
    ~A() {
        cout << "bye world\n";
    }
    void print() {
        cout << "print hello world\n";
        cout << "num : " << num << '\n';
    }
};

int main(void) {
    A *a = new A();
    a->print();
    delete a;
   
    return 0;
}

하지만 malloc/free를 이용해서 클래스를 생성하면 생성자, 소멸자가 호출되지 않음을 볼 수 있다

#include <cstdlib>
#include <iostream>

using namespace std;

class A {
private:
    int num;

public:
    A() {
        num = 3;
        cout << "hello world\n";
    }
    ~A() {
        cout << "bye world\n";
    }
    void print() {
        cout << "print hello world\n";
        cout << "num : " << num << '\n';
    }
};

int main(void) {
    A *a = (A *)malloc(sizeof(A));
    a->print();
    free(a);
    return 0;
}

세그멘테이션 기법

수리노을 — Sun, 10 Nov 2019 11:52:03 +0900

페이징 기법과 대비되는 기법으로 동일한 사이즈로 페이지 블록을 만드는 페이징 기법과 달리 세그멘테이션 기법은 가상메모리를 서로 다른 크기의 논리적 단위인 세그먼트를 분할하는 것을 말한다

페이징 기법에서 초래되는 내부 단편화 문제는 해결할 수 있지만, 실제로 연속적인 물리 메모리 공간이 할당되지 않으면 해당 세그먼트는 물리 메모리 위에 올라가지 못하므로 반대로 외부 단편화를 초래하게 된다

가상 메모리 동작 방식 정리

수리노을 — Fri, 8 Nov 2019 22:26:05 +0900

1. 가상 메모리는 왜 필요한가?

- 폰 노이만 구조에서는 데이터와 명령어가 하나의 메모리로 묶여 있기 때문에, 메모리에 상주해야만 코드를 읽어오는 구조다

- 32비트 리눅스 기준으로 각 프로세스는 4G의 메모리를 할당받는다. 하지만 물리 메모리 크기 한계로 배치 시스템이 아니라면 2개 이상의 프로세스가 상주해야 하는데 불가능하다

2. 가상 메모리를 읽는 방법

- CPU가 MMU에게 현재 프로세스의 가상 주소를 부른다

- CR3 레지스터에 있는 페이지 테이블의 시작주소를 읽고 해당 프로세스의 페이지 테이블로 접근해 물리 주소를 읽어온다. 물리 주소에 접근해서 값을 가져온다

- 페이지 테이블 효율을 위해 약 2단계의 디렉토리로 나누어 페이지 테이블을 생성한다. 만일 4KB의 모든 페이지 테이블을 생성한다면 하나의 프로세스 당 약 2^20개의 테이블을 생성해야만 한다

https://www.youtube.com/watch?v=iqfjWIYyQ9k

return 0와 exit(0)의 차이

수리노을 — Fri, 8 Nov 2019 21:02:29 +0900

컴파일러 동작을 살펴보면, 실제 main이 중심이긴 하지만 _start라는 커널 함수가 먼저 호출된다. _start 함수 내부를 살펴보면

_start() {

main()

exit()

}

와 같이 구성되어 있어 마지막에 상태값이 들어간 exit를 호출하게 된다. 다만 main 안에서 exit를 바로 호출하면 프로세스가 바로 종료되기 때문에 _start 안에서의 main 아래 코드는 호출되지 않고 끝나버린다

cutoff 주파수가 -3dB인 이유

수리노을 — Fri, 8 Nov 2019 16:33:49 +0900

먼저 dB 단위는 좌표계를 log 스케일로 했을 때, 나오는 수치다. 보통 계산을 편하게 하기 위해 10 * log X 값으로 계산하는데 이때 값의 단위를 dB로 한다. log 좌표계의 장점은 큰 수를 간략하게 표현할 수 있다.

전력을 기준으로 할 때는 10*log(X), 전압 혹은 전류를 기준으로 할 때는 20*log(X) dB로 표현한다. 어떠한 기준값 1에 대해서 전력이 반으로 줄어들 때 dB 값이 -3dB이다. 계산은 10log(0.5)로 -3dB가 된다. 다르게 신호에 대해서는 1/sqrt(2)로 0.707로 계산이 된다

[참고] http://www.rfdh.com/bas_rf/begin/whydb.htm

copy on write의 내부 동작

수리노을 — Fri, 8 Nov 2019 02:27:04 +0900

리눅스에서 최근에 프로세스 생성 시 copy on write 기법을 도입해서 물리메모리를 효율적으로 관리하고 있다

1. 자식 프로세스를 생성할 때, 초기에 따로 페이지 테이블을 생성하지 않는다. 부모 프로세스의 페이지 테이블을 우선 사용한다 (포인터 참조의 개념으로 이해)

2. 부모 또는 자식 프로세스가 읽기가 아닌 쓰기를 진행할 때 페이지를 복사하고 분리하게 된다

프로세스 생성 시간과 생성되어야 하는 페이지 수도 줄어든다는 장점이 있다

fork와 exec로 나만의 쉘 만들기

수리노을 — Fri, 8 Nov 2019 01:38:32 +0900

무한루프 안에서 fork와 execlp을 통해서 나만의 쉘을 구성하는 소스코드다. exit를 입력하면 쉘을 빠져나오게 된다

exec 동작 방식

수리노을 — Thu, 7 Nov 2019 21:06:03 +0900

fork 시스템 콜은 새로운 프로세스 공간을 별도로 만들고, 호출한 프로세스는 부모 프로세스 공간을 모두 복사한다. 반면에 exec 시스템 콜은 현재 프로세스 공간의 Text, Data, Bss 영역을 새로운 프로세스의 이미지로 덮어씌운다. 따라서 exec를 실행하면 그 뒤에 있던 Text 코드는 다른 것으로 덮어씌어지게 된다

exec 계열에서 파생된 라이브러리 함수는 다양하다

execl에서 PATH는 환경변수의 경로를 의미한다. arg가 경로를 찾을 수 없을 때 path를 참조한다

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

int main(int argc, char **argv) {
    printf("execute ls\n");    
    execl("/bin/ls", "ls", "-al", NULL); 
    printf("execute ls fail\n");
    return 0;
}

v가 들어간 함수는 arg에 대한 문자열 배열을 미리 정의해서 넣어주는 것이다

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

int main(int argc, char **argv) {
    char *arg[] = { "ls", "-al", NULL };
    printf("execute 'execv'\n");
    execv("/bin/ls", arg);
    perror("execute 'execv' fail\n");
            
    return 0;
}

execlp는 실행파일에 대한 경로를 기본으로 설정되어 있는 PATH에서 찾게 된다. PATH에 잡혀있는 경로를 탐색하면서 명령어를 찾게 된다. 따라서 execlp 함수를 사용할 때는 모든 path를 적을 필요가 없다는 장점이 있다

 printenv | grep "PATH"

프로세스 최대 생성 수

수리노을 — Thu, 7 Nov 2019 15:27:52 +0900

프로세스가 생성할 때마다, 고유의 PID 값을 갖는다. 다만 초기에 제한되는 프로세스가 생성되는 수가 존재한다

기본적으로 signed 16비트 정수가 최대 제한된 수이다

$ sudo cat -n /proc/sys/kernel/pid_max

리눅스 배포판과 그 버전에 따라서 상이할 수 있다

STM32F4 + NRF24L01

수리노을 — Thu, 7 Nov 2019 14:17:18 +0900

https://stm32f4-discovery.net/2014/06/library-17-nrf24l01-stm32f4xx/

입력 임피던스와 출력 임피던스의 의미

수리노을 — Wed, 6 Nov 2019 22:42:03 +0900

전자회로를 시작하고 끝내면서, 특히 razavi 원서를 공부하면서 가장 많이 하는 것이 입력 임피던스와 출력 임피던스를 수식으로 구하는 과정이었다. 그럼 대체 왜 이렇게 수식적으로 계산하고 뽑아내는 것인가?

이상적인 op-AMP를 이야기할 때 입력 임피던스는 무한대, 출력 임피던스는 0으로 정의한다.

https://ko.wikipedia.org/wiki/%EC%97%B0%EC%82%B0_%EC%A6%9D%ED%8F%AD%EA%B8%B0

내부 회로를 살펴보면 Vout은 GVin에 종속되는데, Rout에서 걸리는 전압을 뺀 나머지가 Vout으로 간다고 이해하면 된다

결론부터 말하면, 입력 임피던스는 반드시 큰 것이 좋고, 출력 임피던스는 반드시 작아야만 신호의 손실이 없어진다

Rin이 커야만 신호가 모두 들어오고, Rout이 작아야만 출력이 모두 Vout에 걸린다는 의미다

독립전원과 종속전원, 실제 종속전원은 존재하는 것인가?

수리노을 — Wed, 6 Nov 2019 19:35:09 +0900

독립전원은 회로 내부의 상황과 상관없이 해당 노드에서 일정하게 흐르는 전류를 말한다. 시간에 따라 변하는 sin3t와 같은 함수도 포함된다

반대로 종속전원은 회로 내부의 상황에 따라서 정해지는 전원이다. 총 4가지 종류가 있다

1. 전압종속 전압원

2. 전압종속 전류원

3. 전류종속 전압원

4. 전류종속 전류원

독립전원은 단순히 배터리라고 생각하면 되는데, 그러면 종속전원이라는 것은 존재하는 것인가? 즉 회로 내부에서 결정되는 값에 종속되어 있는 전압원이 실제 모델로 존재하는가가 의문이었다

답은 존재한다! 이다

실제 모델은 전자회로에서 등장하는 BJT와 MOSFET이 그 예이다.

BJT는 base에 들어가는 전류량에 따라 출력 전류가 결정되는 전류 종속 전류원이고, MOSFET은 gate에 걸리는 전압에 따라 출력 전류가 결정되는 전압 종속 전류원이다

[삼성] 17825 주사위 윷놀이

수리노을 — Tue, 5 Nov 2019 20:29:26 +0900

시뮬레이션 문제로, 나한테는 삼성 기출 중에 상당히 까다로운 문제인 것 같다

시간복잡도 계산 시, 브루트 포스로 말의 순서를 정하면 2^20 * 10번의 주사위 * 최대 5번 = 약 5천만으로 1억 안에 해결할 수 있다. map으로 다음 위치로 하나씩 움직이는 점과 모든 말의 순서를 탐색한다는 점이 시간을 오래 걸리게 했다.

계속 틀렸던 이유는 dfs가 아닌 브루트포스로 접근했는데, 말이 움직이지도 못한 채 다음 턴으로 넘어가도 이 부분에서 쌓여진 합이 답의 일부분이 되었다. 그리고 브루트포스로 하니 확실히 0.3초가 걸리는, 효율적이지 못한 시간복잡도를 보였다

문제: https://www.acmicpc.net/problem/17825

깃허브주소: https://github.com/surinoel/boj/blob/master/17825.cpp

깃허브주소(DFS): https://github.com/surinoel/boj/blob/master/17825_dfs.cpp

DFS 코드

Visual Studio 빌드 속도 높이기

수리노을 — Sun, 3 Nov 2019 19:02:18 +0900

1. 최소 다시 빌드 기능인 /Gm을 OFF

2. 다중 프로세서 컴파일 기능인 /MP를 ON

[참조] https://blankspace-dev.tistory.com/296

pthread_join과 pthread_detach의 차이

수리노을 — Sun, 3 Nov 2019 16:32:21 +0900

두 함수 모두 스레드가 종료하면 사용된 자원에 대해서 즉시 free를 한다

다만, join은 두 번째 인자인 void **형태의 반환값을 받아와서 또 다른 제어를 할 수 있다. 하지만 detach는 그런 것 없이 바로 할당된 메모리를 해제한다

그리고 join은 blocking, detach는 non-blocking 함수로, 프로세스인 메인 스레드에서 join의 사용은 뒷 코드의 내용이 바로 실행되지 않는다는 특징이 있다

pthread

수리노을 — Sun, 3 Nov 2019 15:53:44 +0900

pthread는 POSIX 표준 API 스레드다. 기본 glibc 라이브러리 함수가 아닌 libpthread 라이브러리에 포함되어 있으므로 컴파일 시 명시적으로 -pthread 옵션을 명시해야만 한다

스레드 반환값은 어떻게 받아서 확인할 수 있을까? join의 두번째 인자로 받아올 수 있다

파일 API와 mmap 차이

수리노을 — Fri, 1 Nov 2019 11:52:26 +0900

프로세스가 파일을 읽는 방법에는 총 2가지가 있다

1. 파일 디스크립터

2. mmap을 통해 파일의 내용을 메모리에 매핑하여 사용

파일 디스크립터로 파일을 읽는 행위는 지양된다. 물리적인 거리에 의해서 프로세스가 디스크에서 파일을 읽는 속도는 매우 느리다. 그리고 읽는 도중에는 blocking이 되어 있으므로 CPU 효율이 떨어지게 된다

즉 OS 측면에서는

1. 시스템 콜

2. 스케쥴러

3. 인터럽트의 일을 수행하게 되고

컴퓨터구조 단에서는

1. DMA

2. System Bus

을 통해서 개선할 수 있지만 따로 추가해야 하는 부분이다

따라서 mmap의 장점은

1. 가상 메모리에 파일을 매핑하는 mmap을 사용하면 위의 일들을 줄여줄 수 있다

2. 파일의 내용을 읽을 때 제어되는 위치지정자 역시 fseek보다는 포인터로 주소를 옮겨가면서 읽는 것이 훨씬 편하다

 void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset

- addr

커널에게 요청하는 mapping 시작 주소, 커널은 이를 참조만하고 적절하지 않는 위치라면 다른 위치에 파일을 매핑한다. 하지만 flag 옵션에서 MAP_FIXED가 써진다면 요구로 바뀌게되고 커널이 만족하지 못한다면 mmap은 실패하게 된다

- flags

1. MAP_SHARED : 다른 프로세스와 파일의 내용을 공유할 수 있다

2. MAP_PRIVATE

3. MAP_FIXED

프로세스가 종료하면 자동으로 sync, unmap을 해주므로 따로 해주지 않아도 무방하다

$ ls -al > "ls.txt"

void *로 접근해서 파일을 읽는 코드

WRITE 옵션을 추가해서 파일을 수정하는 방법

open과 O_CREAT 그리고 mode_t

수리노을 — Fri, 1 Nov 2019 10:45:53 +0900

파일을 open할 때 두 개의 오버로딩된 함수가 존재한다. 그 중 하나는 맨 마지막에 mode_t가 붙은 하나다

 int open(const char *pathname, int flags, mode_t mode)

mode는 파일을 생성할 때 부여되는 권한 설정이다. 따라서 대개 0644 권한을 많이 대입한다. 반드시 O_CREAT때만 효력이 발생하고, 파일이 존재한다면 mode 권한은 재설정되지 않는다

교착상태 Dead lock

수리노을 — Thu, 31 Oct 2019 18:36:30 +0900

두 개 이상의 작업이 서로 상대방의 작업이 끝나기만을 기다리는 무한 대기 상태

예) 스레드 A, B가 존재하고 자신의 자원은 반환하지 않은 상태에서 상대방의 자원을 요구하는 상태

데드락이 생기기 위한 조건

1. 상호배제 : 둘 이상의 스레드는 동시에 공유자원을 사용할 수 없다

2. 순환대기 : 서로 원하는 자원이 있는 상대방이 순환적으로 연결되어 있다

3. 비선점 : 수행이 완료되기 전까지는 자원을 반납하지 않고, 상대방도 가져갈 수 없다

4. 점유대기 : 자신의 자원을 반환하지 않은 상태에서 상대방의 자원을 요구하고 있다

데드락을 방지하기 위해서는 조건 중 하나라도 성립하지 않으면 된다. 하지만 자원의 낭비가 심하다는 단점이 있다

AD5933 Impedance Analyzer Source Code

수리노을 — Thu, 31 Oct 2019 16:39:52 +0900

https://people.ece.cornell.edu/land/courses/eceprojectsland/STUDENTPROJ/2006to2007/yz226/CIM%20Code.c

cin으로 방어적 프로그래밍

수리노을 — Thu, 31 Oct 2019 16:15:30 +0900

프로그램을 만들 때 사용자의 입장에서 생각해야 한다. 사용자가 입력 범위를 벗어나도, 프로그램을 종료하지 않고 경고 메세지를 띄우거나 따른 조치를 취해야만 한다

1. 하나의 입력에서 여러 데이터를 입력해서 버퍼에 남아있을 때

- cin.ignore은 버퍼를 비워주는 행위로, (비워야하는 최대 사이즈, delimeter)로 최대 사이즈에서 마지막으로 delimeter를 만날 때까지 비워주게 된다

2. 입력 범위를 초과하는 값을 입력했을 때

- cin.fail로 검사할 수 있으며, 위 조건을 만족했을 시 true를 반환한다

#include <iostream>

using namespace std;

int main(void) {
	int x, y;
	char op;
	cin >> x;
	cin.ignore(32767, '\n');
	cin >> op;
	cin >> y;
	if (cin.fail()) {
		cout << "input exceeds int_max\n";
	}
	else {
		if (op == '+') {
			cout << x + y << '\n';
		}
		else {
			cout << x - y << '\n';
		}
	}

	return 0;
}

[참고] 인프런, 따라하면서 배우는 C++ 홍정모

병합정렬

수리노을 — Thu, 31 Oct 2019 15:17:48 +0900

분할정복의 대표적인 예

merge : 정복, sort : 분할, 2개의 함수로 구성되어 있다

1. stable sort 중 하나로 중복 키 순서가 보장된다

2. 평균, 최악, 최고의 시간복잡도는 동일하게 O(NlgN)이다

3. 임시로 저장해야하는 배열이 있어야하므로 기존보다 2배의 메모리를 잡아먹는다

위 채점은 merge sort로 아래 채점은 heap sort이다

깃허브주소: https://github.com/surinoel/boj/blob/master/merge_sort.cpp

점 3개의 방향 알아내기 CCW, CW

수리노을 — Thu, 31 Oct 2019 00:22:36 +0900

x, y 좌표평면에 점 3개가 있고, 넓이를 구함으로써 이어진 점들의 방향이 CW, CCW임을 알 수 있다

[참고] https://www.acmicpc.net/blog/view/27

참고문제: https://www.acmicpc.net/problem/11758

깃허브주소: https://github.com/surinoel/boj/blob/master/11758.cpp

재귀의 장단점

수리노을 — Wed, 30 Oct 2019 22:21:11 +0900

단점 >

함수를 반복적으로 호출하면서 생기는 메모리 사용량과 오버헤드로 인해 성능이 저하된다는 점이 있다. 호출이 되면서 리턴할 주소와 내용들을 저장하고, 돌아갈 때도 이를 불러온다는 점에서 시간이 지연된다

장점 >

특정 알고리즘 구현에 대해서는 보다 표현이 자연스러울 수 있다 (가독성)

- 퀵 정렬, 병합 정렬

- 팩토리얼 구하기

- 그래프 DFS

2042 구간 합 구하기

수리노을 — Wed, 30 Oct 2019 16:05:22 +0900

기본적인 배열을 통한 누적합은 구간합을 구하는 데 O(1)의 짧은 시간복잡도가 걸리지만 값이 변경됐을 때는 최대 N번을 통해 변경을 해야므로, 변경을 한 후 누적합을 구하는 시간복잡도는 O(N)이라고 할 수 있다. 하지만 세그먼트 트리를 구하면 O(lgN)만에 연산을 끝낼 수 있다

문제: https://www.acmicpc.net/problem/2042

깃허브주소: https://github.com/surinoel/boj/blob/master/2042.cpp

세그먼트 트리

수리노을 — Wed, 30 Oct 2019 15:01:52 +0900

구간 합을 구할 때 사용하는 유용한 자료구조인 세그먼트 트리다. 구간 합은 데이터가 나열되어 있을 때, 특정 범위에서의 데이터 합을 말한다. 누적합을 구했다는 가정 하에 구간 합은 O(1)의 시간복잡도로 구할 수 있지만, 변경된 사항이 생긴다면 다시 O(N)의 시간복잡도로 누적합을 수정해야 한다. 하지만 세그먼트 트리를 이용하면 수정했을 때도 트리의 높이인 O(lgN)만으로 누적합을 구할 수 있다

1. 세그먼트 트리(누적합) 만들기

리프 노드를 배열 원소를 하고 루트로 올라갈수록 재귀적으로 누적합이 계산된다. 완전 이진트리로 구성하기 때문에 자식 인덱스는 2*부모 + 1, 2*부모 + 2로 구성된다

https://wkdtjsgur100.github.io/segment-tree/

long long init(int idx, int start, int end) {
	if (start == end) {
		return tree[idx] = arr[start];
	}
	else {
		return tree[idx] = init(2 * idx + 1, start, (start + end) / 2) +
			init(2 * idx + 2, (start + end) / 2 + 1, end);
	}
}

2. 구간합 구하기

일정 구간이 주어졌을 때, 기본으로 만들어진 세그먼트 트리와 비교했을 때 3가지로 나뉠 수 있다

1. 범위가 하나도 겹치지 않을 때

2. 일정 구간이 세그먼트 트리 구간을 포함할 때

3. 그 외

long long sum(int idx, int start, int end, int left, int right) {
	if (left > end || right < start) {
		return 0;
	}
	else if (left <= start && end <= right) {
		return tree[idx];
	}
	else {
		int mid = (start + end) / 2;
		return sum(2 * idx + 1, start, mid, left, right) + 
			sum(2 * idx + 2, mid + 1, end, left, right);
	}
}

3. 값 변경했을 때, 구간합 변경하기

변경하려는 인덱스가 포함된 구간합은 모두 차이만큼 더해준다

void change(int idx, ll diff, int start, int end, int changeidx) {
	if (start > changeidx || end < changeidx) return;

	tree[idx] += diff;
	if (start < end) {
		int mid = (start + end) / 2;
		change(2 * idx + 1, diff, start, mid, changeidx);
		change(2 * idx + 2, diff, mid + 1, end, changeidx);
	}
}