demo_loop_speed

Signal Processing + Control & Dynamics 중심의 Octave 학습 예제

ex-speed/demo_loop_speed.m

코드 인덱스로 돌아가기

카테고리

Performance Drill

학습 소스 그룹

코드 길이

104

lines

작성자

날짜 정보 없음

패키지

signal

pkg load 기준

전체 코드

clc; clear all; close all; addpath(genpath(pwd));
pkg load signal

printf(fmt("{mfilename}\n", "#FF5733"));

n = 100000;
t = linspace(0,10,n);
p = 4;
q = 4;
r = 4;

printf("speed_test1\n");
tic
[x, y, z] = speed_test1(n, p, q, r, t);
toc

tic
printf("speed_test2\n");
[x, y, z] = speed_test2(n, p, q, r, t);
toc

tic
printf("speed_test3\n");
[x, y, z] = speed_test3(n, p, q, r, t);
toc

tic
printf("speed_test4\n");
[x, y, z] = speed_test4(n, p, q, r, t);
toc

tic
printf("speed_test5\n");
[x, y, z] = speed_test5(n, p, q, r, t);
toc

# 핵심: 가장 긴 반복 루프를 벡터화해야 함
# 참조: speed_test5. 0.828358 seconds

# Elapsed time is 185.905 seconds.
# Elapsed time is 37.5481 seconds.
# Elapsed time is 9.04582 seconds.
# Elapsed time is 2.43174 seconds.
# Elapsed time is 0.811938 seconds.

# ################################################################################
# # 실행 속도 비교 실험: 다차원 배열 연산 방법에 따른 성능 차이 분석
# ################################################################################

# ## 실험 목적
# 본 실험은 다차원 배열에 대해 다양한 연산 방식을 적용하여 실행 속도를 비교하는 것이다.
# 특히, 중첩 루프와 벡터화 연산이 실행 시간에 미치는 영향을 평가한다.

# ## 함수 설명

# ### speed_test1: 중첩 루프를 이용한 삼각함수 계산
# - 목적: `sin(t)`, `cos(t)`, `sin(t) * cos(t)` 값을 각각 계산하여 배열에 저장
# - 실행 방식: `for` 루프를 네 번 중첩하여 각 요소를 개별적으로 할당
# - 실행 시간: **171.573 seconds** (매우 느림)
# - 비효율적인 점: 매번 개별 요소에 접근하여 연산을 수행하므로, 반복문 오버헤드가 크다.

# ### speed_test2: 중첩 루프를 이용한 랜덤 값 할당 (4x1 벡터)
# - 목적: `rand(4,1)` 값을 다차원 배열의 마지막 차원에 할당
# - 실행 방식: 세 개의 중첩 `for` 루프를 사용하며, 네 번째 차원 전체를 한 번에 할당
# - 실행 시간: **37.3639 seconds**
# - 개선점: 마지막 차원을 한 번에 처리하여 `speed_test1`보다 빠르지만, 여전히 다중 루프 사용으로 인해 비효율적

# ### speed_test3: 중첩 루프를 줄여 랜덤 값 할당 (4x4 행렬)
# - 목적: `rand(4,4)` 값을 다차원 배열의 마지막 두 차원에 할당
# - 실행 방식: `for` 루프를 두 개만 사용하고, `rand(4,4)`를 한 번에 할당
# - 실행 시간: **8.75345 seconds**
# - 개선점: 두 개의 루프를 제거하여 `speed_test2`보다 크게 성능 향상

# ### speed_test4: 최적화된 랜덤 값 할당 (4x4x4 3D 배열)
# - 목적: `rand(4,4,4)` 값을 다차원 배열에 한 번에 할당
# - 실행 방식: `for` 루프를 단 하나만 사용하여 `rand(4,4,4)`를 한 번에 할당
# - 실행 시간: **2.21251 seconds**
# - 우수한 점: 벡터화 연산을 적극적으로 활용하여 실행 시간을 대폭 단축함

# ### speed_test5: 벡터화 연산을 이용한 삼각함수 계산
# - 목적: `sin(t)`, `cos(t)`, `sin(t) * cos(t)` 값을 벡터 연산으로 계산
# - 실행 방식: 루프를 사용하지 않고 `:` 연산자를 이용하여 벡터화된 연산 수행
# - 실행 시간: **0.828358 seconds** (가장 빠름)
# - 최적화된 점: 모든 연산을 벡터화하여 반복문 없이 직접 계산 및 할당 수행

# ## 결론 및 분석
# 1. **반복문을 줄이는 것이 실행 시간을 단축하는 핵심 요소**
#    - `speed_test1`이 가장 느린 이유는 `for` 루프를 네 번 중첩했기 때문.
#    - `speed_test2`~`speed_test4`에서는 루프를 점진적으로 줄이며 속도가 개선됨.
   
# 2. **벡터화 연산이 가장 효과적인 최적화 방법**
#    - `speed_test5`는 `speed_test1`과 동일한 계산을 수행하지만, 벡터 연산을 활용하여 **약 207배** 빠르게 실행됨.
#    - MATLAB에서 `for` 루프 대신 행렬 연산을 사용하는 것이 성능 최적화의 핵심임.

# 3. **다차원 배열의 할당 방식도 성능에 영향을 미친다**
#    - `speed_test2`에서 마지막 차원을 한 번에 할당하는 방식(`rand(4,1)`)이 `speed_test1`보다 빠름.
#    - `speed_test3`, `speed_test4`에서는 `rand(4,4)`, `rand(4,4,4)`를 한 번에 할당하여 루프를 줄이면서 성능이 크게 개선됨.

# ## 최종 추천
# - MATLAB에서는 가능하면 **벡터화 연산**을 적극적으로 활용해야 한다.
# - 반복문을 사용할 경우, **배열의 크기에 맞게 할당을 최적화**하는 것이 중요하다.
# - 다차원 배열의 값을 할당할 때, **가능한 한 큰 블록 단위로 연산을 수행**하는 것이 성능을 극대화하는 방법이다.

전체 코드를 복사해서 Octave에서 바로 실행할 수 있습니다.

clc; clear all; close all; addpath(genpath(pwd));
pkg load signal

printf(fmt("{mfilename}\n", "#FF5733"));

n = 100000;
t = linspace(0,10,n);
p = 4;
q = 4;
r = 4;

printf("speed_test1\n");
tic
[x, y, z] = speed_test1(n, p, q, r, t);
toc

tic
printf("speed_test2\n");
[x, y, z] = speed_test2(n, p, q, r, t);
toc

tic
printf("speed_test3\n");
[x, y, z] = speed_test3(n, p, q, r, t);
toc

tic
printf("speed_test4\n");
[x, y, z] = speed_test4(n, p, q, r, t);
toc

tic
printf("speed_test5\n");
[x, y, z] = speed_test5(n, p, q, r, t);
toc

# 핵심: 가장 긴 반복 루프를 벡터화해야 함
# 참조: speed_test5. 0.828358 seconds

# Elapsed time is 185.905 seconds.
# Elapsed time is 37.5481 seconds.
# Elapsed time is 9.04582 seconds.
# Elapsed time is 2.43174 seconds.
# Elapsed time is 0.811938 seconds. 

# ################################################################################
# # 실행 속도 비교 실험: 다차원 배열 연산 방법에 따른 성능 차이 분석
# ################################################################################

# ## 실험 목적
# 본 실험은 다차원 배열에 대해 다양한 연산 방식을 적용하여 실행 속도를 비교하는 것이다.
# 특히, 중첩 루프와 벡터화 연산이 실행 시간에 미치는 영향을 평가한다.

# ## 함수 설명

# ### speed_test1: 중첩 루프를 이용한 삼각함수 계산
# - 목적: `sin(t)`, `cos(t)`, `sin(t) * cos(t)` 값을 각각 계산하여 배열에 저장
# - 실행 방식: `for` 루프를 네 번 중첩하여 각 요소를 개별적으로 할당
# - 실행 시간: **171.573 seconds** (매우 느림)
# - 비효율적인 점: 매번 개별 요소에 접근하여 연산을 수행하므로, 반복문 오버헤드가 크다.

# ### speed_test2: 중첩 루프를 이용한 랜덤 값 할당 (4x1 벡터)
# - 목적: `rand(4,1)` 값을 다차원 배열의 마지막 차원에 할당
# - 실행 방식: 세 개의 중첩 `for` 루프를 사용하며, 네 번째 차원 전체를 한 번에 할당
# - 실행 시간: **37.3639 seconds**
# - 개선점: 마지막 차원을 한 번에 처리하여 `speed_test1`보다 빠르지만, 여전히 다중 루프 사용으로 인해 비효율적

# ### speed_test3: 중첩 루프를 줄여 랜덤 값 할당 (4x4 행렬)
# - 목적: `rand(4,4)` 값을 다차원 배열의 마지막 두 차원에 할당
# - 실행 방식: `for` 루프를 두 개만 사용하고, `rand(4,4)`를 한 번에 할당
# - 실행 시간: **8.75345 seconds**
# - 개선점: 두 개의 루프를 제거하여 `speed_test2`보다 크게 성능 향상

# ### speed_test4: 최적화된 랜덤 값 할당 (4x4x4 3D 배열)
# - 목적: `rand(4,4,4)` 값을 다차원 배열에 한 번에 할당
# - 실행 방식: `for` 루프를 단 하나만 사용하여 `rand(4,4,4)`를 한 번에 할당
# - 실행 시간: **2.21251 seconds**
# - 우수한 점: 벡터화 연산을 적극적으로 활용하여 실행 시간을 대폭 단축함

# ### speed_test5: 벡터화 연산을 이용한 삼각함수 계산
# - 목적: `sin(t)`, `cos(t)`, `sin(t) * cos(t)` 값을 벡터 연산으로 계산
# - 실행 방식: 루프를 사용하지 않고 `:` 연산자를 이용하여 벡터화된 연산 수행
# - 실행 시간: **0.828358 seconds** (가장 빠름)
# - 최적화된 점: 모든 연산을 벡터화하여 반복문 없이 직접 계산 및 할당 수행

# ## 결론 및 분석
# 1. **반복문을 줄이는 것이 실행 시간을 단축하는 핵심 요소**
#    - `speed_test1`이 가장 느린 이유는 `for` 루프를 네 번 중첩했기 때문.
#    - `speed_test2`~`speed_test4`에서는 루프를 점진적으로 줄이며 속도가 개선됨.
   
# 2. **벡터화 연산이 가장 효과적인 최적화 방법**
#    - `speed_test5`는 `speed_test1`과 동일한 계산을 수행하지만, 벡터 연산을 활용하여 **약 207배** 빠르게 실행됨.
#    - MATLAB에서 `for` 루프 대신 행렬 연산을 사용하는 것이 성능 최적화의 핵심임.

# 3. **다차원 배열의 할당 방식도 성능에 영향을 미친다**
#    - `speed_test2`에서 마지막 차원을 한 번에 할당하는 방식(`rand(4,1)`)이 `speed_test1`보다 빠름.
#    - `speed_test3`, `speed_test4`에서는 `rand(4,4)`, `rand(4,4,4)`를 한 번에 할당하여 루프를 줄이면서 성능이 크게 개선됨.

# ## 최종 추천
# - MATLAB에서는 가능하면 **벡터화 연산**을 적극적으로 활용해야 한다.
# - 반복문을 사용할 경우, **배열의 크기에 맞게 할당을 최적화**하는 것이 중요하다.
# - 다차원 배열의 값을 할당할 때, **가능한 한 큰 블록 단위로 연산을 수행**하는 것이 성능을 극대화하는 방법이다.

코드 해설

목적

Signal Processing + Control & Dynamics 중심의 Octave 학습 예제

입력

스크립트 상단에서 정의한 파라미터/입력 데이터를 사용합니다.

출력

콘솔 텍스트 출력

실행 흐름

# 실행 속도 비교 실험: 다차원 배열 연산 방법에 따른 성능 차이 분석
본 실험은 다차원 배열에 대해 다양한 연산 방식을 적용하여 실행 속도를 비교하는 것이다
특히, 중첩 루프와 벡터화 연산이 실행 시간에 미치는 영향을 평가한다
- 비효율적인 점: 매번 개별 요소에 접근하여 연산을 수행하므로, 반복문 오버헤드가 크다
- 우수한 점: 벡터화 연산을 적극적으로 활용하여 실행 시간을 대폭 단축함
### speed_test5: 벡터화 연산을 이용한 삼각함수 계산
- 실행 방식: 루프를 사용하지 않고 `:` 연산자를 이용하여 벡터화된 연산 수행
- 최적화된 점: 모든 연산을 벡터화하여 반복문 없이 직접 계산 및 할당 수행
2. **벡터화 연산이 가장 효과적인 최적화 방법**
- MATLAB에서 `for` 루프 대신 행렬 연산을 사용하는 것이 성능 최적화의 핵심임

핵심 함수/주제

randprintfcossinaddpathfmtgenpathlinspace

실습 과제

샘플링 주파수나 입력 주파수를 바꿔 스펙트럼 변화를 비교해보세요.
질량/감쇠/강성 또는 전달함수 계수를 바꿔 응답 변화를 확인해보세요.
핵심 함수 rand의 인자를 한 가지 바꿔 결과 변화를 기록해보세요.

학습 팁

입력 파일 경로가 현재 작업 디렉터리 기준인지 먼저 확인하세요.

같은 카테고리의 다른 코드

demo_save_option
ex-speed/demo_save_option.m
speed_test1
ex-speed/speed_test1.m
speed_test2
ex-speed/speed_test2.m
speed_test3
ex-speed/speed_test3.m
speed_test4
ex-speed/speed_test4.m
speed_test5
ex-speed/speed_test5.m