승코딩당당당

[AUTOSAR] Communication 구조와 BSW 통신 스택 정리

승코딩당당당 — Tue, 24 Mar 2026 09:01:24 +0900

AUTOSAR Communication 구조는 소프트웨어 컴포넌트 간의 데이터 교환을 효율적으로 수행하고, 하드웨어와의 결합도를 낮추기 위해 계층적으로 설계되어 있다. SWC와 Runnable을 기반으로 기능을 분리하고, RTE를 통해 컴포넌트 간 통신을 추상화함으로써 시스템의 재사용성과 확장성을 확보한다.

이 과정에서 BSW는 하드웨어와 상위 애플리케이션 사이를 연결하는 핵심 역할을 수행하며, System Services, ECU Abstraction, MCAL로 구성된 계층 구조를 통해 하드웨어 의존성을 최소화한다. 또한 Com, Dcm, Dem과 같은 통신 및 진단 모듈과 PduR, CanIf, CAN Driver로 이어지는 통신 흐름을 통해 데이터가 실제 네트워크로 전달된다.

특히 NM과 CanSM은 네트워크의 상태를 관리하여 불필요한 전력 소모를 줄이고, FlexRay와 같은 통신 방식은 시스템 설계에 따라 구조적 제약을 갖는다는 점에서 AUTOSAR 통신 구조의 특징을 잘 보여준다.

이 글에서는 AUTOSAR의 전체 통신 흐름과 주요 BSW 모듈의 역할을 중심으로, 각 계층이 어떻게 연결되고 동작하는지에 대해 정리한다.

Overview

software component(SWC) 단위로 기능을 구성한다 (객체지향 개념)
- 기능 단위로 분리된 모듈
- 단독으로 동작하지 못하고 다른 SWC와 상호작용하여 동작
Runnable은 SWC 내부에서 실제로 동작하는 함수 단위
- RTE를 통해 데이터를 주고 받는다
  - [SWC A - Runnable] ↔ RTE ↔ [SWC B - Runnable]
RTE(Runtime Environment)
- SWC와 SWC, 그리고 SWC와 하드웨어 사이를 연결하는 중간 계층
- 컴포넌트들이 서로를 직접 알지 않아도 통신 가능하도록 하는 인터페이스 역할
전체 구조
- ASW(Application Layer) ← RTE ← BSW(Basic Software) ← MCU
BSW는 크게 3단계 구조로 나뉜다
- System Services
  - OS 및 시스템 공통 기능 제공
  - 시스템 전체 동작을 관리
  - 예: OS(스케줄링), 통신 서비스, 메모리 관리, 진단 서비스
- ECU Abstraction Layer
  - 하드웨어를 직접 다루지 않도록 추상화
  - 하드웨어 변경에 대한 영향을 최소화
  - 예: 센서 추상화, 통신 모듈 추상화, 메모리 HW 추상화
- MCAL (Microcontroller Abstraction Layer)
  - 하드웨어 레지스터를 직접 제어하는 계층
  - 디바이스 드라이버 역할 수행
  - 예: GPIO Driver, ADC Driver, PWM Driver, CAN Driver
AUTOSAR 통신 구조
- server는 항상 동작하지 않음
- client의 요청이 있을 때 해당 요청을 처리하는 방식으로 동작

BSW

https://yoginsavani.com/understanding-autosar-architecture-a-guide-to-automotive-software-integration/#google_vignette

BSW는 하드웨어와 상위 소프트웨어를 연결하는 핵심 계층
BSW 모듈 구성
- 노란색 블록
  - 특정 기능을 수행하는 개별 모듈
  - 하나의 명확한 역할을 담당
  - 예: 메모리, 입출력, 진단 등
- 파란색 블록
  - 여러 모듈이 계층적으로 구성된 구조
  - 주로 통신 스택에서 나타남
  - 데이터 패킹, 라우팅, 인터페이스 처리 등 여러 단계 포함
Transceiver
- MCU와 CAN Bus 사이에서 신호를 변환하는 장치
- 구조: MCU ↔ CAN Controller ↔ Transceiver ↔ CAN Bus
  - MCU/Controller: 디지털 신호
  - CAN Bus: 전압 기반 신호
- 디지털 신호를 실제 통신 가능한 전기 신호로 변환
- 통신을 위해 반드시 필요
NM (Network Management)
- 네트워크 상태를 관리하는 모듈
- 필요할 때만 네트워크를 활성화하고, 필요 없을 때는 절전 상태로 전환
- 역할
  - Wake-up: 네트워크 활성화
  - 유지: ECU 상태 확인 및 통신 유지
  - Sleep: 네트워크 절전 상태 전환
CanSM (CAN State Manager)
- CAN 통신 상태를 제어하는 모듈
- 통신 시작, 정상 동작, 오류 상태, 절전 상태 등을 관리
- NM과의 관계
  - NM: 네트워크 사용 여부 결정
  - CanSM: 실제 CAN 상태 전환 수행
Com / Dcm / Dem
- Com (Communication Module)
  - SWC의 데이터를 네트워크로 송수신
- Dcm (Diagnostic Communication Manager)
  - 외부 진단 장비와 ECU 간 통신 처리
- Dem (Diagnostic Event Manager)
  - 에러 발생 기록 및 관리
PduR (PDU Router)
- 데이터를 목적지로 전달하는 라우터 역할
- 상위 모듈(Com, Dcm)과 하위 통신 모듈(CAN, LIN 등) 연결
FlexRay
- 정적 스케줄 기반 통신 (Time-triggered)
- 모든 ECU가 정해진 시간 슬롯에 따라 통신 수행
- 특징
  - 높은 신뢰성과 실시간성
  - 구조 변경 시 전체 스케줄 영향

CAN Interface module (CanIf)

CanIf
- 상위 통신 모듈과 CAN Driver 사이를 연결하는 인터페이스
Hardware Object (Mailbox)
- CAN Controller 내부의 메모리 버퍼
- 송신/수신 메시지를 저장
- 설정에 따라 특정 메시지를 처리
Hardware Object Handler (HoH)
- Hardware Object를 추상화한 개념
- CanIf가 PDU를 HoH로 변환하여 CAN Driver 호출
CAN Driver
- 어떤 CAN Controller의 어떤 Hardware Object를 사용할지 설정 정보 보유
- 해당 버퍼에 메시지를 할당하여 실제 전송 수행

[AUTOSAR] OS Task 기반 LED 제어 실습 (TRK-MPC560XB)

승코딩당당당 — Fri, 20 Mar 2026 09:20:17 +0900

이번 실습에서는 AUTOSAR OS 환경에서 Task를 생성하고, 이를 주기적으로 실행하여 LED를 제어하는 과정을 수행하였다. 단순히 while문으로 LED를 제어하는 것이 아니라, AUTOSAR의 Task와 Alarm 기반 스케줄링 구조를 활용하여 실시간 시스템에서의 동작 흐름을 이해하는 데 목적이 있다.

특히, OS 레벨에서 Task가 어떻게 생성되고 실행되는지, 그리고 해당 Task가 실제 하드웨어 제어로 이어지는 과정을 직접 구현해보며 AUTOSAR 구조에 대한 이해를 높일 수 있었다.

실습 환경

보드: TRK-MPC560XB
MCU: MPC5606B
개발 환경: mobilgene C Studio
AUTOSAR Classic Platform 기반

실습 목표

AUTOSAR OS Task 생성 및 설정
Task를 Application에 등록
Alarm을 이용한 주기 실행 구조 이해
GPIO 레지스터 제어를 통한 LED 토글 구현

Task 생성 및 설정

AUTOSAR 설정 파일(ARXML)에서 OsTask_LED_Init Task를 생성하였다.

Activation: 1
Priority: 1
Schedule: FULL

Task는 AUTOSAR OS에서 관리되는 실행 단위로, 해당 설정을 통해 OS가 Task의 실행 우선순위와 스케줄링 방식을 결정하게 된다.

Application 연결

생성한 Task는 OsApplication에 등록하였다.

이 과정은 매우 중요한 단계로, Task를 생성하는 것만으로는 실행되지 않으며, 반드시 Application에 연결되어야 OS가 해당 Task를 실행 대상으로 인식한다.

Task 구현

Task 내부에서는 LED를 ON/OFF하는 로직을 구현하였다.

static 변수를 활용하여 상태를 유지하고, Task가 실행될 때마다 값을 반전시켜 LED가 깜빡이도록 구성하였다.

GPIO 제어는 레지스터 직접 접근 방식으로 수행하였다.

LED ON: STD_LOW 출력
LED OFF: STD_HIGH 출력

이 과정을 통해 MCU의 포트를 직접 제어하는 방식과 AUTOSAR 환경에서의 하드웨어 제어 흐름을 동시에 확인할 수 있었다.

동작 구조

이번 실습의 전체 흐름은 다음과 같다.

Alarm → Task Activate → Task 실행 → GPIO 제어

즉, AUTOSAR OS가 Task를 스케줄링하고, 해당 Task가 실행되면서 하드웨어를 제어하는 구조이다.

단순 반복문이 아닌 OS 기반 실행 구조를 사용한다는 점이 핵심이다.

실습 결과

Task가 주기적으로 실행되며 LED2가 일정한 주기로 깜빡이는 것을 확인하였다.

이를 통해 AUTOSAR OS의 Task 스케줄링과 실제 하드웨어 제어가 정상적으로 연결되어 동작함을 검증할 수 있었다.

[AUTOSAR] AUTOSAR 기반 소프트웨어 플랫폼과 OS 구조 정리

승코딩당당당 — Fri, 20 Mar 2026 09:09:15 +0900

자동차 소프트웨어는 점점 더 복잡해지고 있으며, 다양한 제어기와 기능을 효율적으로 통합하기 위해 표준화된 플랫폼이 필수적으로 요구되고 있다. 이러한 흐름 속에서 등장한 것이 AUTOSAR 기반 소프트웨어 플랫폼으로, 하드웨어와 독립적인 구조를 통해 소프트웨어 재사용성과 안전성을 동시에 확보할 수 있도록 한다.

이 글에서는 소프트웨어 플랫폼의 개념과 필요성을 시작으로, AUTOSAR의 구조와 Classic/Adaptive의 차이, 그리고 실제 차량 시스템에서 중요한 역할을 하는 AUTOSAR OS의 핵심 요소(Task, Interrupt, Alarm, Resource 등)를 정리하였다. 특히 실시간 시스템에서 요구되는 스케줄링 방식과 우선순위 관리, 그리고 안정적인 동작을 위한 메커니즘까지 함께 다루며 전체적인 흐름을 이해할 수 있도록 구성하였다.

이를 통해 AUTOSAR가 단순한 개발 프레임워크를 넘어, 자동차 소프트웨어의 재사용성, 안전성, 확장성을 모두 고려한 표준 아키텍처임을 이해하는 데 목적이 있다.

https://kjy1010.tistory.com/42

소프트웨어 플랫폼

소프트웨어 플랫폼 개요

제어계층에서 응용 SW와 HW를 연결해주는 중간 계층
표준 인터페이스와 공통 기능 모듈 제공

소프트웨어 플랫폼 개발 배경

제어기 수량 증가 및 차량 공간 제약으로 인해 제어기 통합 필요
제어기 SW 복잡성 증가 → 플랫폼 공용화 및 표준화 필요
차량 변경 시 HW 변경 → 기능 확장을 위해 플랫폼 필요
ISO 26262 기능안전 표준 준수 필요
- AUTOSAR는 ISO 26262를 기본적으로 따르므로
- 애플리케이션만 검증하면 됨 → 개발 부담 감소

HKMC 플랫폼 특징

최신 차량용 기반 기술의 국제 표준화 및 사양화
고성능 MCU 기반 → 다양한 도메인으로 확장 가능
전 분야 공용 표준화 플랫폼 제공
차세대 통신 기술 및 기능안전 대응

AUTOSAR 정의

AUTOmotive Open System ARchitecture
재사용 가능한 자동차 SW 아키텍처

AUTOSAR 버전

Classic AUTOSAR
Adaptive AUTOSAR (자율주행, 고성능 시스템 대응)

Classic AUTOSAR

RTOS 기반
C 언어
적용: 샤시, 파워트레인, 진단
특징: 실시간성, 경량, 고신뢰성

Adaptive AUTOSAR

POSIX 기반 OS
C++, 일부 Python
적용: IVI, 자율주행, V2X
특징: 고성능 처리, 유연성, OTA 지원

AUTOSAR 개발 과정

자동차 SW는 신뢰성과 안전성이 핵심
직접 코딩 최소화 → 오류 감소 목적
설계 기반 자동 코드 생성
- 오류 발생 시 설계 문제로 판단

Top-Down 방식 개발
- 컴포넌트 정의
- 컴포넌트 간 통신 구조 정의

AUTOSAR 플랫폼 구조

개발 생산성 향상
표준 준수로 안전성 확보
HW 독립 구조 → SW 재사용 가능

Application Layer

HW와 독립적인 응용 SW 정의
AUTOSAR Interface를 통해 통신
ECU 독립적인 Interface Mapping 제공
RTE 표준 인터페이스만 사용하여 SWC 개발 가능
- 통신 구조 몰라도 개발 가능
- 통신 구조 변경에도 영향 없음

AUTOSAR Interface

사용자 설정 기반 API 자동 생성
포트, 데이터 정의 → API 생성

Standardized AUTOSAR Interface

표준에서 정의된 인터페이스 사용
동일한 API 구조 유지

BSW (Basic Software)

애플리케이션의 직접적인 HW 접근 차단
계층 구조로 구성
단점: 함수 호출 증가 → 실행 시간 증가 → 실시간성 영향

What are the benefit

SW Reusability
- HW 독립적인 SW 설계
- 높은 재사용성 → 비용 절감
- SWC 간 안정적 연결
- HW 변경 시에도 SW 재사용 가능
SW Safety
- 검증된 SW 재사용 가능
- 표준 프로세스를 통한 안전성 확보
Cost Efficiency
- OEM 측면
  - 재사용으로 개발 기간 단축
  - ARXML 기반 명확한 커뮤니케이션
  - 다양한 부품사 통합 가능
- Supplier 측면
  - 다양한 OEM 대응 가능
  - AUTOSAR 기반 → 타 OEM에도 공급 가능

AUTOSAR OS

OSEK/VDX 개요

Real-time 시스템
- Hard Real-time
  - 반드시 지켜야 하는 Deadline 존재
  - 미충족 시 시스템 실패
- Soft Real-time
  - 성능 저하 허용
  - 예: 영상 스트리밍

OSEK/VDX OS

Task
- OS가 관리하는 실행 단위
- 복잡한 기능을 여러 Task로 분할
Task State Model
- Task 상태 변화 존재
- Basic Task / Extended Task
- Basic Task
  - 이벤트 없음
- Extended Task
  - Event 기반 대기 상태 존재

Task - Scheduling

Full Preemptive
- 높은 우선순위 Task가 즉시 선점
Non Preemptive
- 현재 Task 종료까지 대기
우선순위는 개발자가 설정

Task - Context Switching

Context
- 실행 중 Task 상태 정보 (Register 등)
Context Save
- 현재 Task 상태를 메모리에 저장
Context Load
- 새로운 Task 상태를 MCU에 적용
Switching 시간 최소화 중요

Task - PreTaskHook / PostTaskHook

Task 실행 전/후 사용자 정의 루틴
디버깅 및 시간 측정에 활용

Interrupt

Interrupt
- 외부 장치 이벤트 발생
- 예: CAN 수신, 타이머 만료
Exception
- CPU 내부 이벤트
Trap
- 소프트웨어 인터럽트
- system call 시 발생

Interrupt 특징

Task를 선점
Category 1
- OS 서비스 미사용
- 빠름
- Task scheduling 영향 없음
Category 2
- OS 서비스 사용
- Context 저장 필요 → 느림
- scheduling 영향 있음

Interrupt와 Task Scheduling

Cat.2 종료 후 재스케줄링 수행
모든 interrupt 종료 후 task 실행

Alarm

Counter 기반 이벤트 발생 객체
특정 시점 도달 시 수행
- Task 활성화
- Event 설정
- Callback 실행
주기적 Task 실행에 사용
1 Tick = 1μs
- 10000 Tick = 1초

Resource

공유 자원 보호 메커니즘
종류
- Standard
- Internal
- Linked

우선순위 역전

낮은 우선순위 Task가 자원을 점유하는 문제

Priority Ceiling Protocol

자원 획득 시 우선순위 상승
Release 시 원래 우선순위 복귀

Error

ErrorHook

오류 발생 시 사용자 정의 처리 루틴

[C++] 백준 2606: 바이러스

승코딩당당당 — Wed, 11 Mar 2026 14:50:34 +0900

문제

[C++] 백준 2606: 바이러스 SILVER 3
https://www.acmicpc.net/problem/2606

접근 방법

백준 2606번은 컴퓨터 바이러스 문제로,
1번 컴퓨터가 바이러스에 감염되었을 때 연결된 다른 컴퓨터가 몇 대 감염되는지 구하는 문제다.

컴퓨터들이 네트워크로 연결되어 있기 때문에, 이를 그래프 탐색 문제로 볼 수 있다.

문제의 핵심은 다음과 같다.

컴퓨터 = 노드
네트워크 연결 = 간선

따라서 그래프 탐색(DFS 또는 BFS) 을 이용해서 1번 컴퓨터에서 시작하여 연결된 모든 컴퓨터를 방문하면 된다.

이번 풀이에서는 DFS(Depth First Search) 를 사용했다.

먼저 그래프를 인접 리스트 형태로 저장한다.

vector<vector<int>> graph;

그리고 방문 여부를 확인하기 위해 배열을 사용했다.

vector<bool> visited;

DFS는 다음과 같이 구현했다.

void dfs(int node)
{
    visited[node] = true;

    for (int i = 0; i < graph[node].size(); i++)
    {
        int next = graph[node][i];

        if (!visited[next])
            dfs(next);
    }
}

1번 컴퓨터부터 DFS를 시작하면 같은 네트워크로 연결된 모든 컴퓨터가 방문된다.

마지막으로 1번 컴퓨터를 제외한 방문된 컴퓨터 수를 세면 감염된 컴퓨터 수가 된다.

구현 시 주의할 점

그래프는 양방향이다.
마지막 cnt에서 수를 갱신할 때 1번 컴퓨터는 제외하도록 2번 노드부터 for문을 돌린다.

코드

#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> graph;
vector<bool> visited;

void dfs(int node)
{
	visited[node] = true;
	for (int i = 0; i < graph[node].size(); i++)
	{
		int next = graph[node][i];
		if (!visited[next])
			dfs(next);
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int n = 0, m = 0;
	cin >> n >> m;

	graph.resize(n + 1);
	visited.resize(n + 1, false);
	for (int i = 0; i < m; i++)
	{
		int a = 0, b = 0;
		cin >> a >> b;

		graph[a].push_back(b);
		graph[b].push_back(a);
	}

	dfs(1);

	int cnt = 0;
	for (int i = 2; i <= n; i++)
	{
		if (visited[i])
			cnt++;
	}
	cout << cnt;
}

[C++] 백준 10826: 피보나치 수 4

승코딩당당당 — Mon, 9 Mar 2026 15:02:51 +0900

문제

[C++] 백준 10826: 피보나치 수 4 SILVER 5
https://www.acmicpc.net/problem/10826

접근 방법

백준 10826번은 N번째 피보나치 수를 출력하는 문제다.
하지만 일반적인 피보나치 문제와 달리 값의 크기가 매우 커진다.

예를 들어 N이 커지면 피보나치 값은 수백 자리 이상의 정수가 되기 때문에long long 같은 기본 정수 타입으로는 저장할 수 없다.

그래서 이 문제는 큰 정수(Big Integer) 를 직접 구현해야 한다.
이를 위해 문자열(string) 을 이용해서 덧셈을 구현했다.

피보나치 점화식은 다음과 같다.

F(n) = F(n-1) + F(n-2)

하지만 문자열끼리 바로 덧셈이 되지 않기 때문에 문자열 덧셈 함수 add()를 만들어 계산했다.

문자열 덧셈의 동작 방식은 다음과 같다.

두 문자열을 뒤집어서 1의 자리부터 계산하도록 만든다.
각 자리 숫자를 더하면서 carry(올림) 를 처리한다.
결과 문자열을 다시 뒤집어서 정상적인 숫자 형태로 만든다.

이렇게 구현하면 매우 큰 숫자도 문제없이 계산할 수 있다.

이후 피보나치 수열은 DP 방식으로 계산했다.

vector<string> fibo(n + 1, "0");
fibo[1] = "1";

for (int i = 2; i <= n; i++)
    fibo[i] = add(fibo[i - 1], fibo[i - 2]);

문자열 덧셈을 이용해 이전 두 값을 더하면서 fibo[n]을 구하면 된다.

구현 시 주의할 점

n이 0인 경우 처리
- 만약 n이 0이라면 벡터 크기는 1이 되고 유효한 인덱스는 fibo[0]뿐이다.
  그런데 바로 fibo[1] = "1"; 에 접근하면 범위를 벗어나 런타임 에러가 발생한다.
큰 정수 덧셈을 쉽게 구현하기 위해 문자열을 뒤집어서 1의 자리부터 계산하도록 하는 것이 중요하다.
- 대신 마지막에 결과 ret를 리턴할 때도 reverse를 해주어야 한다.

reverse(a.begin(), a.end());
reverse(b.begin(), b.end());

코드

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

string add(string a, string b)
{
	reverse(a.begin(), a.end());
	reverse(b.begin(), b.end());

	string ret = "";
	int carry = 0, index = 0;

	while (index < a.size() && index < b.size())
	{
		int num = (a[index] - '0') + (b[index] - '0') + carry;
		carry = num / 10;
		num %= 10;
		ret += char(num + '0');
		index++;
	}
	while (index < a.size())
	{
		int num = (a[index] - '0') + carry;
		carry = num / 10;
		num %= 10;
		ret += char(num + '0');
		index++;
	}
	while (index < b.size())
	{
		int num = (b[index] - '0') + carry;
		carry = num / 10;
		num %= 10;
		ret += char(num + '0');
		index++;
	}

	if (carry > 0)
		ret += char(carry + '0');

	reverse(ret.begin(), ret.end());
	return ret;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int n = 0;
	cin >> n;

	vector<string> fibo(n + 1, "0");
	if (n != 0)
	{
		fibo[1] = "1";
		for (int i = 2; i <= n; i++)
			fibo[i] = add(fibo[i - 1], fibo[i - 2]);
	}
	cout << fibo[n];

	return 0;
}

[C++] 백준 2749: 피보나치 수 3

승코딩당당당 — Sun, 8 Mar 2026 23:34:01 +0900

문제

[C++] 백준 2749: 피보나치 수 3 GOLD 2
https://www.acmicpc.net/problem/2749

접근 방법

백준 2749번은 N번째 피보나치 수를 1,000,000으로 나눈 나머지를 구하는 문제다.

문제의 핵심은 N의 범위가 매우 크다는 것이다.
N은 최대 10^18까지 주어질 수 있기 때문에, 단순히 피보나치 수열을 N까지 계산하는 방법으로는 해결할 수 없다.

이 문제를 해결하기 위해 피사노 주기(Pisano Period) 개념을 이용한다.

피보나치 수열을 어떤 수 으로 나눈 나머지는 반복되는 주기를 가진다.
이 반복되는 길이를 피사노 주기라고 한다.

이 문제를 풀기 전에 백준 9471번 문제를 먼저 풀고 오는 것을 추천한다.

상세 아이디

1. 피사노 주기 구하기

피사노 주기는 다음 성질을 가진다.

k(m) ≤ m² - 1

따라서 다음처럼 반복하면서 다시 (1, 1)이 등장하는 순간을 찾으면 된다.

int pisano(LL n)
{
    LL previous = 1, current = 1;
    LL k = 0;

    for (LL i = 0; i < n * n; i++)
    {
        k = (previous + current) % n;
        previous = current;
        current = k;

        if (previous == 1 && current == 1)
            return i + 1;
    }
}

m = 1,000,000일 때 피사노 주기가 1,500,000 이기 때문에,

pisano 함수를 사용하지 않고 아래와 같이 값을 직접 사용해도 된다.

LL k = 1500000;

2. 실제 계산할 인덱스 구하기

주기를 이용하면 계산해야 할 인덱스는 아래와 같다.

LL index = n % k;

즉, N번째 피보나치 수를 직접 구할 필요 없이 index번째 피보나치 수만 계산하면 된다.

3. 피보나치 계산

vector<LL> fibo(index + 2, 0);
fibo[1] = 1;

for (LL i = 2; i <= index; i++)
    fibo[i] = (fibo[i - 1] + fibo[i - 2]) % 1000000;

피보나치 값 자체는 매우 커지므로 항상 % 1000000을 해주면서 계산해야 한다.

구현 시 주의할 점

N이 최대 10^18이기 때문에 반드시 long long을 사용해야 한다.
피보나치 값을 그대로 계산하면 안 된다
- 피보나치 수는 매우 빠르게 커지므로 매 단계마다 mod 연산을 해줘야 한다.
피사노 주기를 이용해야 시간 내 해결 가능

코드

#include <iostream>
#include <vector>
using namespace std;

typedef long long LL;

int pisano(LL n)
{
	LL previous = 1, current = 1;
	LL k = 0;
	for (LL i = 0; i < n * n; i++)  // k(m) <= m^2 - 1
	{
		k = (previous + current) % n;
		previous = current;
		current = k;

		if (previous == 1 && current == 1)
			return i + 1;
	}
	return 0;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	LL n = 0;
	cin >> n;

	LL k = pisano(1000000);  // 반복되는 주기 = 1,500,000
	LL index = n % k;

	vector<LL> fibo(index + 2, 0);
	fibo[1] = 1;
	for (LL i = 2; i <= index; i++)
		fibo[i] = (fibo[i - 1] + fibo[i - 2]) % 1000000;

	cout << fibo[index];
}

[C++] 백준 9471: 피사노 주기

승코딩당당당 — Sat, 7 Mar 2026 23:33:50 +0900

문제

[C++] 백준 9471: 피사노 주기 SILVER 4
https://www.acmicpc.net/problem/9471

접근 방법

백준 9471번은 피사노 주기(Pisano Period) 를 구하는 문제다.

피보나치 수열을 어떤 정수 m으로 나눈 나머지를 계속 계산하면 수열이 일정한 주기를 가지고 반복된다.
이 반복되는 길이를 피사노 주기라고 한다.

예를 들어, 피보나치 수열을 3으로 나눈 나머지를 보면

1 1 2 0 2 2 1 0 1 1 ...

이렇게 특정 구간 이후부터 동일한 패턴이 반복된다.
이 반복되는 길이가 바로 피사노 주기 k(m) 이다.

상세 아이디

피사노 주기는 다음 성질을 가진다.

k(m) ≤ m² − 1

즉, 최대 m^2번 정도만 확인하면 반드시 주기가 발견된다.
그래서 반복문을 m * m 범위까지만 돌려서 주기를 찾는다.

피보나치 수열을 계속 계산하면서 나머지 값만 유지하면 된다.

LL previous = 1, current = 1;

초기 피보나치 값은 F1 = 1, F2 = 1 이다.

이후 다음 값은 아래로 계산한다.

k = (previous + current) % m;

그런 후, 아래와 같이 갱신하면서 계속 진행한다.

previous = current
current = k

주기 판별:

피사노 주기는 1, 1이 다시 등장하는 순간 시작된다.

따라서 다음 조건을 확인하면 된다.

if (previous == 1 && current == 1)
    return i + 1;

이 순간이 주기의 길이가 된다.

구현 시 주의할 점

피보나치 값을 그대로 계산하면 안 된다
- 피보나치 수는 매우 빠르게 커지기 때문에 값 자체를 저장하면 오버플로우가 발생한다.
데이터 타입은 long long으로 해주어야 정상적으로 출력된다.
- 처음에 그냥 int로 했다가 테스트 케이스 4번이 0으로 출력되는 현상이 발생했다.

코드

#include <iostream>
using namespace std;

typedef long long LL;

LL pisano(LL m)
{
	LL previous = 1, current = 1;
	LL k = 0;
	for (LL i = 0; i < m * m; i++)  // k(m) <= m^2 - 1
	{
		k = (previous + current) % m;
		previous = current;
		current = k;

		if (previous == 1 && current == 1)
			return i + 1;
	}
	return 0;
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	int p = 0;
	cin >> p;

	for (int i = 0; i < p; i++)
	{
		LL n = 0, m = 0;
		cin >> n >> m;

		cout << n << ' ' << pisano(m) << '\n';
	}
}

[최적화] 임베디드 C 코드 최적화 전략 정리

승코딩당당당 — Tue, 3 Mar 2026 17:13:02 +0900

개요

임베디드 시스템은 제한된 메모리와 낮은 연산 자원을 기반으로 동작하는 경우가 많기 때문에, 동일한 기능을 구현하더라도 코드를 어떻게 작성하느냐에 따라 성능과 자원 사용량이 크게 달라진다. 특히 MCU 환경에서는 ROM과 RAM이 모두 한정되어 있고, 실행 속도 또한 시스템 안정성과 직결되기 때문에 C 코드 최적화는 선택이 아니라 필수에 가깝다.

이번 글에서는 임베디드 C 코드 최적화를 메모리 관점, 실행 속도 관점, 데이터 처리 관점, 흐름 제어 관점으로 나누어 정리하였다. 단순히 “빠르게 만드는 방법”이 아니라, 메모리 절약과 실행 속도 향상 사이의 균형을 어떻게 잡아야 하는지에 초점을 두고 살펴본다. 또한 자료형 선택, 타입 변환 최소화, 비트 연산 활용, 루프 최적화, 인라인 함수 사용 등 실제 현장에서 자주 적용되는 기법들을 체계적으로 정리하였다.

임베디드 C 코드 최적화

메모리관점에서의 C코드 최적화

ROM 최적화
- 프로그램 코드, 상수, 초기화된 전역 변수와 정적 변수는 ROM 영역에 저장된다.
- 코드와 상수를 줄이는 것이 핵심이다.
- 방법
  - 데드 코드 제거
  - 매크로나 인라인 함수의 무분별한 사용 지양 (코드 크기 증가 가능)
  - 불필요한 전역 변수 초기화 제거
  - 상수나 전역 변수 대신 지역 변수 사용
  - 표현을 간결하게 작성하고 불필요한 중간 연산 생략
  - 표준 라이브러리 사용 최소화 (코드 크기 증가 가능)
RAM 최적화
- RAM에는 초기화되지 않은 전역 변수, 정적 변수, 지역 변수, 함수 인자, 함수 호출 시 발생하는 context(Stack/Heap)가 포함된다.
- Stack 사용량을 줄이는 것이 중요하다.
- 방법
  - 함수 호출 깊이를 줄인다.
  - 작은 함수는 매크로나 인라인으로 대체 (Stack 사용 감소 목적)
  - 구조체나 배열 대신 포인터 활용
  - 비트 플래그 활용
  - 값이 변하지 않는 전역 변수는 const로 선언

실행속도 관점에서의 C코드 최적화

실행시간을 줄이는 최적화
- 인라인 함수 사용
  → 함수 호출 오버헤드 제거 (단, 코드 크기 증가 가능)
- 참조 테이블(Lookup Table) 활용
- 인라인 어셈블리 활용
- 전역 변수 사용
  → 함수 호출 시 파라미터 전달 오버헤드 감소
  (단, 모듈화 저하 가능)
- 폴링 방식 활용
  → 인터럽트 대비 오버헤드가 적은 경우 존재
- 정수 연산 활용
  → 부동소수점 연산을 고정소수점 또는 정수 연산으로 대체

실행속도 vs 메모리 관점에서의 C코드 최적화

실행속도를 높이는 최적화와 메모리를 절약하는 최적화는 서로 충돌할 수 있다.
- 예: 인라인 함수는 실행속도는 증가시키지만 코드 크기는 증가
시스템 요구사항에 맞춰 균형을 잡는 것이 중요하다.

Data Handling (데이터 처리)

Data handling 관련 방법들

Data Types Usage
Avoid Type Conversion
Unsigned Advantage
Float & Double
Constant & Volatile
Data Alignment – Arrangement & Packing
Pass by Reference
Others

Data type 사용 / Type conversion

Data Types Usage
- 적절한 Data Type 선택은 재귀 연산이나 대규모 배열 처리에서 매우 중요하다.
- 불필요하게 큰 타입을 사용하면 메모리와 처리 시간이 증가한다.
- 예) 변수 범위가 0~200이면 unsigned char 사용이 적절하다.
Avoid Type Conversion
- 가능한 동일한 타입의 변수끼리 연산하도록 설계한다.
- 타입 변환은 추가적인 CPU 사이클을 소모한다.
- Signed와 Unsigned는 서로 다른 타입으로 간주된다.

Signed & Unsigned / Float & Double

Signed & Unsigned 구분
- Unsigned: 몫/나머지 연산, loop counter, 배열 인덱싱
- Signed: 음수 연산이 필요한 경우
Float & Double
- Float 최대값: 0x7f7fffff
- Double 최대값: 0x7f7fffffffffffff
- float 상수는 ‘f’를 명시하여 불필요한 double 변환 방지
  예) x = y + 0.2f;

Constant와 volatile

Constant
- const로 선언하면 ROM에 저장된다.
- 상수 데이터를 RAM에 중복 저장하지 않도록 하기 위함이다.
- 읽기 전용 데이터는 반드시 const 처리한다.
Volatile
- 컴파일러의 최적화를 방지한다.
- 인터럽트에 의해 변경되는 변수, I/O 레지스터에 사용한다.
- 항상 메모리에서 값을 읽도록 보장한다.

Data Alignment - Arrangement & Packing

구조체 설계 시 메모리 정렬 고려
- 32비트 MCU에서는 32비트 단위 정렬이 효율적
- char 등 작은 타입은 묶어서 선언하면 패딩 최소화 가능

Pass by Reference

함수 인자가 많아질수록 push/pop 동작이 증가한다.
구조체를 포인터로 전달하면 오버헤드를 줄일 수 있다.

Initialization

적절한 메모리 할당 방식 사용 시 RAM 사용량 감소 가능
초기화 전략은 메모리 배치에 큰 영향을 준다.

Return 값

함수의 Return 값은 레지스터에 저장된다.
반환값이 필요 없다면 void로 선언하여 불필요한 오버헤드를 줄인다.

비트 플래그 사용

상태 플래그를 char로 선언하면 최소 1byte 사용
여러 상태는 비트 단위로 묶어 관리하면 메모리 절약 가능

Flow Control Handling (흐름제어 처리)

Flow Control Handling 관련 방법들

Use of switch statement
Inline function
Loop unrolling
Loop Hoisting
Loop Overhead
Others

If vs switch

하나의 변수로 분기할 경우 switch가 효율적
switch는 lookup table 방식으로 동작 가능
if는 조건에 따라 실행 시간이 달라질 수 있음

Inline 코드 사용

함수 호출을 코드 복사로 대체
호출 오버헤드 제거
작은 함수에서 효과적
큰 함수는 코드 크기 증가 문제 발생

Loop Hoisting

루프 내부 계산을 외부로 이동
반복 연산 감소 → 실행 시간 단축

Loop overhead

MCU는 0 비교 분기에 최적화된 경우가 많음
“0이 아닌지 검사”가 특정 값 비교보다 효율적

If - else

불필요한 else는 제거

함수 인자의 개수 제한

함수 인자는 4개 이내 권장
그 이상은 stack 사용 → 성능 저하 가능

Other Handling (기타 처리)

Other Handling 관련 방법들

Use of operators
Use formula
Inline Assembly
Fixed point & Floating point
Others

Use of operators

기본 연산자를 효율적으로 활용

Replacing: Integer Division with Multiplication

정수 나눗셈은 가장 느린 연산 중 하나
가능한 경우 곱셈으로 대체
오버플로 발생 여부 반드시 고려

Use of Formula

Horner’s Rule 적용
인수분해 활용
덧셈으로 곱셈을 대체 가능한 경우 고려

Inline assembly

asm 키워드를 활용하여 어셈블리 코드 삽입
속도 향상 목적
C와 어셈블리를 혼합하여 사용 가능

부동소수점 연산 제거

실수 대신 정수/고정소수점 사용 권장
예) 평균 계산 후 마지막 단계에서만 변환 수행

조건문 최적화

조건문 대신 bit 연산 활용 가능

마무리 정리

임베디드 C 코드 최적화는 단순히 코드를 줄이거나 빠르게 만드는 기술이 아니라, 시스템 자원을 전략적으로 사용하는 설계 능력과 연결된다.

ROM을 줄이기 위한 최적화
RAM 사용량을 최소화하는 설계
실행 시간을 단축하는 구조
불필요한 연산과 타입 변환 제거
인터럽트, I/O, 비트 연산 등 하드웨어 특성을 고려한 코드 작성

이러한 요소들은 서로 영향을 주며 때로는 상충하기도 한다. 예를 들어 인라인 함수는 속도를 높일 수 있지만 코드 크기를 증가시킬 수 있다. 따라서 최적화는 “무조건 빠르게”가 아니라, 시스템 요구사항에 맞는 균형점(Balance)을 찾는 과정이다.

결국 좋은 임베디드 코드는
✔ 자원을 낭비하지 않고
✔ 예측 가능한 실행 시간을 가지며
✔ 하드웨어 특성을 이해하고 작성된 코드이다.

최적화는 마지막 단계에서 억지로 하는 작업이 아니라, 설계 단계부터 고려되어야 하는 기본 역량임을 기억하는 것이 중요하다.

[C++] 백준 11725: 트리의 부모 찾기

승코딩당당당 — Tue, 3 Mar 2026 15:50:50 +0900

문제

[C++] 백준 11725: 트리의 부모 찾기 SILVER 2
https://www.acmicpc.net/problem/11725

접근 방법

이 문제는 루트가 1번인 트리가 주어졌을 때, 각 노드의 부모를 출력하는 문제다.

트리는 사이클이 없는 연결 그래프이기 때문에,
1번 노드를 기준으로 DFS를 한 번만 돌면서 부모를 기록해주면 해결된다.

구현 아이디어는 간단하다:

graph : 인접 리스트 (양방향 그래프)
ret[i] : i번 노드의 부모 노드 번호
visited[i] : 방문 체크

DFS에서

void dfs(int before, int now)
{
    visited[now] = true;
    ret[now] = before; // now의 부모는 before

    for (int i = 0; i < graph[now].size(); i++)
    {
        int next = graph[now][i];

        if (!visited[next])
            dfs(now, next);  // 현재 노드(now)를 다음 노드(next)의 부모로 넘김
    }
}

이렇게 현재 노드의 부모를 before 파라미터로 받도록 해서, 재귀 호출을 할 때마다 자연스럽게 부모–자식 관계를 채운다.

루트 노드인 1번에서 시작할 때는 부모가 없으므로 dfs(0, 1); 처럼 0을 넘겨서 시작한다. (0은 단순한 더미 값)

DFS가 끝난 뒤에는

for (int i = 2; i <= n; i++)
    cout << ret[i] << '\n';

2번 노드부터 N번 노드까지의 부모만 출력하면 된다.
(1번은 루트라 부모가 없음)

구현 시 주의할 점

트리 입력은 간선이 양방향으로 주어지므로 양쪽 모두에 넣어줘야 한다.

graph[index].push_back(val);
graph[val].push_back(index);

DFS에서 부모를 찾을 때, 바로 이전 노드만 부모라고 단정할 수 없으므로 visited 배열로 이미 방문한 노드를 다시 타고 들어가지 않게 해야 한다.
그렇지 않으면 부모–자식 관계가 꼬이거나 무한 재귀가 발생할 수 있다.
인덱스는 1부터 N까지 사용하므로, graph, visited, ret는 모두 n + 1 크기로 잡는 것이 안전하다.
루트(1번 노드)의 부모는 의미가 없으니 출력에서 제외하고, 2번 노드부터 출력해야 한다는 점을 잊지 말기.

코드

#include <iostream>
#include <vector>
using namespace std;

vector<vector<int>> graph;
vector<int> ret;
vector<bool> visited;
int n;

void dfs(int before, int now)
{
	visited[now] = true;
	ret[now] = before;

	for (int i = 0; i < graph[now].size(); i++)
	{
		int next = graph[now][i];

		if (!visited[next])
			dfs(now, next);
	}
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	cin >> n;

	graph.resize(n + 1);
	visited.resize(n + 1, false);
	ret.resize(n + 1, 0);
	for (int i = 1; i < n; i++)
	{
		int index = 0, val = 0;
		cin >> index >> val;

		graph[index].push_back(val);
		graph[val].push_back(index);
	}
	dfs(0, 1);

	for (int i = 2; i <= n; i++)
		cout << ret[i] << '\n';
}

[C++] 백준 1850: 최소공약수

승코딩당당당 — Mon, 2 Mar 2026 18:30:48 +0900

문제

[C++] 백준 1850: 최소공약수 SILVER 1
https://www.acmicpc.net/problem/1850

접근 방법

백준 1850번은 두 정수 A와 B가 주어졌을 때, 각각이 1로만 이루어진 수(1111… 형태) 라고 생각하고
그 둘의 최대공약수에 해당하는 1의 개수를 출력하는 문제다.

핵심 아이디어는 다음과 같다.

111…(A개) 와 111…(B개)의 최대공약수는
1이 GCD(A, B)개 있는 수가 된다.

즉,

두 수의 최대공약수를 먼저 구하고
그 개수만큼 1을 출력하면 된다.

따라서 문제의 본질은 두 수의 최대공약수(GCD)를 구하는 것이다.
유클리드 호제법을 이용하면 효율적으로 계산할 수 있다.

int GCD(ll a, ll b)
{
    if (a % b == 0)
        return b;
    else
        return GCD(b, a % b);
}

최대공약수를 구한 뒤,

ll gcd = GCD(a, b);
for (ll i = 0; i < gcd; i++)
    cout << 1;

이렇게 gcd번 반복하면서 1을 출력하면 된다.

구현 시 주의할 점

반드시 long long 사용
- 문제에서 A와 B의 범위가 매우 크기 때문에 int로는 처리할 수 없다.
실제로 큰 수를 만들지 않는다
- 1111… 같은 수를 직접 문자열이나 숫자로 만들면 메모리와 시간 모두 감당할 수 없다.

코드

#include <iostream>
using namespace std;

typedef long long ll;

int GCD(ll a, ll b)
{
	if (a % b == 0)
		return b;
	else
		return GCD(b, a % b);
}
int main()
{
	ios::sync_with_stdio(false);
	cin.tie(NULL);
	cout.tie(NULL);

	ll a = 0, b = 0;
	cin >> a >> b;

	ll gcd = GCD(a, b);
	for (ll i = 0; i < gcd; i++)
		cout << 1;
}