kkamagui의 작업실

13 Git 사용법

Wed, 30 Nov 2011 11:13:20 +0900

13.Git 사용법

들어가기 전에...

이 글은 kkamagui에 의해 작성된 글입니다.
마음껏 인용하시거나 사용하셔도 됩니다. 단 출처(http://kkamagui.tistory.com, http://kkamagui.springnote.com)는 밝혀 주십시오.
기타 사항은 mint64os at gmail.com 이나 http://kkamagui.tistory.com으로 보내주시면 반영하겠습니다.
상세한 내용은 책 "64비트 멀티코어 OS 원리와 구조"를 참고하기 바랍니다.

1.Git에 user.name과 user.email 설정

사용자가 kkamagui이고 email이 kkamagui@gmail.com이라면 아래와 같이 입력하면 된다.

$>git config --global user.name "kkamagui"
$>git config --global user.email "kkamagui@gmail.com"

2.Git에 설정된 global config 값들 표시

$>git config --global --list

3.표시되는 메시지를 컬러로 보기

Git에서 표시되는 메시지는 기본적으로 단색이다. 그런데 이를 컬러로 보고 싶다면 아래와 같이 입력하면 된다.

$>git config --global color.ui "auto"

4.문자셋 설정하기

Git에서 사용하는 문자셋은 기본적으로 UTF-8이다. 만약 UTF-8이 아닌 EUC-KR을 사용하고 싶다면 아래처럼 입력하면 된다.

$>git config --global i18n.commitEncoding cp949
$>git config --global i18n.logOutputencoding cp949

5.내장 도움말 보기

Git에서 내장된 도움말을 보고 싶다면 아래처럼 입력하면 된다.

$>git help <command>

예를 들어 commit에 대한 도움말을 보고 싶다면 git help commit과 같이 입력하는 식이다.

6.Git Project 생성하기

testgit 디렉토리를 만들어서 Git으로 버전관리를 하고 싶다면 아래와 같이 입력하면 된다.

$>mkdir testgit
$>cd testgit
$>git init
Initialized empty Git repository in /home/kkamagui/project/testgit/.git/

7.저장소에 파일 추가하기

testgit에 a.txt 파일을 추가하고 싶다면 아래와 같이 입력하면 된다.

$>git add a.txt

8.저장소의 상태 확인하기

testgit 디렉토리의 상태를 알고 싶으면 아래와 같이 입력하면 된다.
$>git status
kkamagui@ubuntu:~/project/testgit$ git status
# On branch master
#
# Initial commit
#
# Changes to be committed:
# (use "git rm --cached <file>..." to unstage)
#
# new file: a.txt
#

9.변경사항 로컬 저장소에 저장하기

변경사항을 로컬 저장소(Local Repository)에 저장하고 싶다면 아래와 같이 입력한다.

$>git commit -m "최초 추가"
[master (root-commit) 237a76b] 최초 추가
1 files changed, 3 insertions(+), 0 deletions(-)
create mode 100644 a.txt

10.변경 이력 보기

변경 이력(Commit Log)를 보고 싶다면 아래와 같이 입력한다.

$>git log
commit 237a76b9f3ccd65df523d6434d5ea4fa14142079
Author: kkamagui <kkamagui@gmail.com>
Date: Wed Nov 30 10:57:13 2011 +0900

최초 추가

변경 이력이 많을 경우 범위를 개수를 제한할수 있는데, -숫자를 입력하면 된다. 예를 들어 최근 변경 이력 하나만 보고 싶다면 아래와 같이 입력한다.

$>git log -1

kkamagui의 작업실

Wed, 30 Nov 2011 10:45:20 +0900

KKAMAGUI의 작업실 >ㅁ<)/~

KKAMAGUI와 관련된 개발관련 문서/자료가 있는 곳~!!!

블로그 사이트를 티스토리로 이동했습니다. ^^ http://kkamagui.tistory.com, http://www.mint64os.pe.kr

이전까지 포스팅은 까마구 이글루스 블로그에 있습니다.

RSS 주소는 아래와 같습니다.(크윽 찾기가 힘들군요 ㅠ_ㅠ).

http://kkamagui.springnote.com/pages.rss

방명록을 추가하였습니다. 글을 남기실 분은 아래를 클릭하세요. ^ㅡ^

99 방명록 <== 클릭하세요 ^^

내용 빵빵한 스프링노트 주소 모음입니다. ^ㅡ^

91 스프링노트 주소 모음 <== 클릭하세요 ^^

OS 제작에 관련된 자료를 찾으신다면 아래를 클릭하세요 ^ㅡ^

<64비트 멀티코어 OS 원리와 구조>

유용한 안드로이드 애플리케이션을 찾으신다면 아래를 클릭하세요 ^ㅡ^

00 KKAMAGUI 소개 : 나에 대한 소개
00 포트폴리오(Portfolio) : 나의 작품들

01 OS 및 OS 프레임워크 : KKAMAGUI OS Framework 프로젝트
02 NDS 및 ARM : NDS 홈브루 및 커널 개발 프로젝트
03 File System : 각종 파일 시스템 개발 프로젝트
04 PSP 및 MIPS : PSP 홈브루 및 커널 개발 프로젝트 MIPS
05 안드로이드(Android) : 안드로이드(Android) 관련 프로젝트
07 리눅스 프로그래밍 : 리눅스 프로그래밍에 대한 내용들
08 윈도우 시스템 프로그래밍 : 윈도우 시스템 프로그래밍에 대한 내용들
09 파이썬(Python) 프로그래밍 : Python을 이용한 프로그래밍에 대한 내용들
10 웹(Web) 프로그래밍 : HTML, Java Script 등등의 프로그래밍에 대한 내용들
11 DB(Database) 프로그래밍 : DB를 생성하고 관리하는 방법에 대한 내용들
12 루비(Ruby) 프로그래밍 : 루비(Ruby)를 이용한 프로그래밍에 대한 내용들
11 서평
13 Git 사용법 : Git 사용법에 대한 내용들

50 Code Complete : 더 나은 코드를 쓰기위한 내용들

20 프로그래밍 팁 : 각종 프로그래밍 언어에 대한 팁들
21 자작 유틸 및 라이브러리 : 내가 직접 작성한 프로그램 및 라이브러리
22 괜찮은 툴 및 라이브러리 : 사용하기에 편리하거나 기발한 툴 및 라이브러리
23 윈도우 사용 팁

30 해킹/보안 : 각종 보안 프로그램 해킹 및 보안에 관한 내용들
80 스프링노트, 블로그 사용 팁 : 스프링 노트 및 블로그 사용에 대한 각종 팁들
99 기타 : 기타 내용들
100 TODO : 해야할 일들

프로그래밍 외

98 운동
97 자세교정

테스트 코드

16 VI 관련

Mon, 07 Nov 2011 01:36:18 +0900

1.우분투에서 VI에 Taglist 설치 방법

http://vim.sourceforge.net/scripts/script.php?script_id=273 에서 Taglist를 다운로드
다운로드해서 압축을 푼 것을 etc/vim 디렉터리에 그대로 복사
- 이때 doc와 plugin 디렉터리 그대로 옮김
vi를 실행해서 Tlist를 실행하면 좌측에 Taglist가 생김

2.Keymapping 바꾸는 방법

창간의 이동을 F3키로 이동
- map <F3> <c-w> <c-w>
Taglist 표시
- map <F4> :Tlist <cr>

3.Ruby syntax 관련 플러그인 설치 방법

https://github.com/vim-ruby/vim-ruby 에서 파일을 다운로드 받은 뒤 bin 디렉터리에 있는 rb 파일을 실행

4.한글 인코딩 자동으로 해주는 방법

환경 설정 파일을 열어서 set fileencodings=utf-8,euc-kr 로 입력해서 저장해두면 자동으로 판단해서 열어줌

5.폰트 설정 방법

set guifont=MS_Mincho:h12:cANSI

6.내 VI 설정

colorscheme darkblue
set number
set fileencodings=utf-8,euc-kr
set ts=4
set sts=4
set sw=4

set guifont=dejavu_sans_mono:h11:cANSI

noh

set nobackup

http://sourceforge.net/projects/dejavu/files/dejavu/2.33/dejavu-fonts-ttf-2.33.tar.bz2/download << 폰트 있는 곳

7.문자열 치환 방법

http://gypark.pe.kr/wiki/Vi%EB%A1%9C%EB%AC%B8%EC%9E%90%EC%97%B4%EC%B9%98%ED%99%98%ED%95%98%EA%B8%B0

:(시작줄),(끝줄)s/찾을패턴/바꿀스트링/옵션

:5,10s/a/b/     - 5번째 줄부터 10번째 줄까지 각 줄의 첫번째 "a" 를 "b" 로 바꾼다.
:.,.+10s/a/b/g  - 현재 줄부터 (현재 행번호+10)번째 줄까지 모든 "a" 를 "b" 로 바꾼다.
:1,$s/a/b/c     - 첫번째 줄부터 마지막 줄까지 (즉 문서 전체) 각 줄의 "a" 를 "b" 로 바꾸되, 사용자에게 확인을 받는다.
:%s/a/b/gi      - 역시 문서 전체에서 "a" 와 "A" 를 "b" 로 바꾼다.
:%s/Hello/Good Morning/g - 당연히... 두 글자 이상의 문자열도 검색 및 치환이 가능하다.

12 루비(Ruby) 프로그래밍

Wed, 26 Oct 2011 01:38:05 +0900

http://benelog.springnote.com/pages/84624/attachments/30264

http://caar.egloos.com/398176

http://shampu.clus.org/tc/Shampu/363

http://ruby.about.com/od/tk/a/Tk.htm

@ruby 책

http://www.ruby-doc.org/docs/ProgrammingRuby/

*.화면 출력

1.메시지 출력

puts "Hello World"

2.메시지 연결

puts "Hello" + "World"

3.메시지에 변수 출력

message = "Hello World"

puts "my Message is #{message}"

*.Array 다루기

1.빈 Array 만들기
empty1 = []
empty2 = Array.new

2.문자열을 쉽게 Array로 바꾸기
a = %w{ ant bee cat dob elk }
=> ["ant", "bee", "cat", "dob", "elk"]
a[0]    »    "ant"
a[3]    »    "dog"

3.Hash 쓰기
instSection = {
'cello'     => 'string',
'clarinet' => 'woodwind',
'drum'      => 'percussion',
'oboe'      => 'woodwind',
'trumpet'   => 'brass',
'violin'    => 'string'
}
instSection['oboe']    »    "woodwind"
instSection['cello']    »    "string"
instSection['bassoon']    »    nil

histogram = Hash.new(0)
histogram['key1']    »    0
histogram['key1'] = histogram['key1'] + 1
histogram['key1']    »    1

4.범위 안에 데이터를 모두 Array로 만들기
(0..10).to_a
=>[ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

5.3x3 2차원 Array 만들기

doublearray = []
doublearray[0] = (0..2).to_a
doublearray[1] = (3..5).to_a
doublearray[2] = (6..8).to_a
doublearray
=> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

*.제어문

1.if 문 사용법

if count > 10
  puts "Try again"
elsif tries == 3
  puts "You lose"
else
  puts "Enter a number"
end

if radiation > 3000
  puts "Danger, Will Robinson"
end

위는 아래처럼도 사용 가능

puts "Danger, Will Robinson" if radiation > 3000

while square < 1000
   square = square*square
end

위는 아래처럼 사용 가능

square = square*square  while square < 1000

1.Case문

irb(main):023:0> a = 2
=> 2
irb(main):024:0> case a
irb(main):025:1> when 1; puts 1
irb(main):026:1> when 2; puts 2
irb(main):027:1> end
2
=> nil

caes문을 사용할 때 꼭 case에 넘겨주는 변수가 없어도 됩니다. 그렇게하면 차례로 when 문이 실행되므로 가장 처음 참인 문장이 실행되고 빠지게 됩니다. 예를들면,

irb(main):028:0> a = 2
=> 2
irb(main):029:0> case
irb(main):030:1* when a == 1; puts 1
irb(main):031:1> when a == 2; puts 2
irb(main):032:1> when a == 3; puts 3
irb(main):033:1> end

2.Loop

irb(main):003:0> for i in list
irb(main):004:1> puts i if i % 5 == 0
irb(main):005:1> end
5
10
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):006:0>

range로도 가능합니다.

irb(main):006:0> for i in (1..10)
irb(main):007:1> puts i if i % 5 == 0
irb(main):008:1> end
5
10
=> 1..10
irb(main):009:0>

여기서 (1..10)이 1부터 10까지의 range죠. range는 쉽게 list로 바꿀 수 있습니다.

irb(main):009:0> (1..10).to_a
=> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
irb(main):010:0>

3.가변 인자

이외에도, 매개변수에 기본 값을 준다던가 또는 임의 개수의 인자를 받는 다던가 하는 것도 가능합니다. 임의 개수의 인자를 받는 부분을 보죠.

http://www.ibm.com/developerworks/kr/library/x-rubytextproc/index.html

irb(main):029:0> def g(*args)
irb(main):030:1> a1, a2 = args[0], args[1]
irb(main):031:1> puts a1
irb(main):032:1> puts a2
irb(main):033:1> end
=> nil
irb(main):034:0> g(1,2)
1
2
=> nil
irb(main):035:0>

*args로 쓰면 인자를 리스트로 받게 됩니다.

한편 루비는 position에 의해 인자를 구분합니다. 함수에 준 첫번째 인자는 함수의 첫번째 매개변수에 들어가고, 두번째 인자는 함수의 두번째 인자에 들어가죠. 그러나 해싱을 사용해 named parameter를 구현할 수 있습니다. 방법은, 함수의 마지막 인자가 해시일때는 { } 를 사용해 명시적으로 해당 인자가 해시임을 지정하지 않아도 된다는 점을 이용하는 것입니다.

irb(main):006:0> def f(opt, vars)
irb(main):007:1> a1, a2 = vars[:a1], vars[:a2]
irb(main):008:1> puts "opt = #{opt}\ta1 = #{a1}\ta2 = #{a2}"
irb(main):009:1> end
=> nil
irb(main):010:0> f(1, :a1=> 1, :a2 => 2)
opt = 1 a1 = 1 a2 = 2
=> nil
irb(main):011:0>

4.정규표현식

http://www.rubyist.net/~slagell/ruby/regexp.html

You can also match one of a group of characters within a pattern. Some common examples are character classes such as ``\s'', which matches a whitespace character (space, tab, newline, and so on), ``\d'', which matches any digit, and ``\w'', which matches any character that may appear in a typical word. The single character ``.'' (a period) matches any character.

/\d\d:\d\d:\d\d/     # a time such as 12:34:56
/Perl.*Python/       # Perl, zero or more other chars, then Python
/Perl\s+Python/      # Perl, one or more spaces, then Python
/Ruby (Perl|Python)/ # Ruby, a space, and either Perl or Python

정규 표현식을 이용한 문자열 매칭 여부 비교시 =~ 사용 가능

if line =~ /Perl|Python/
  puts "Scripting language mentioned: #{line}"
end

line.sub(/Perl/, 'Ruby')    # replace first 'Perl' with 'Ruby'
line.gsub(/Python/, 'Ruby') # replace every 'Python' with 'Ruby'

*.Code Block 사용법

def callBlock
  yield
  yield
end

callBlock { puts "In the block" }

produces:
In the block
In the block

5.times {  print "*" }
3.upto(6) {|i|  print i }
('a'..'e').each {|char| print char }
produces:
*****3456abcde

*.화면 입출력

printf "Number: %5.2f, String: %s", 1.23, "hello"

Number:  1.23, String: hello

line = gets
print line

while gets           # assigns line to $_
  if /Ruby/          # matches against $_
    print            # prints $_
  end
end

키보드로 입력을 매 라인마다 받아서 입력 값이 Ruby일 때 화면에 출력하는 예제

ARGF.each { |line|  print line  if line =~ /Ruby/ }

5.if문

if count > 10
puts "Try again"
elsif tries == 3
puts "You lose"
else
puts "Enter a number"
end

0.두 개 이상의 리턴값 전달하기 및 받기

def function

return [0, 1]

end

a,b = function()

*.class 처리

class Song
  def initialize(name, artist, duration)
    @name     = name
    @artist   = artist
    @duration = duration
  end
end

`aSong = Song.new("Bicylops", "Fleck", 260)`
`aSong.inspect`	»	`"#<Song:0x401b4924 @duration=260, @artist=\"Fleck\", @name=\"Bicylops\">"`

inspect는 Object의 모든 변수와 ID를 반환

`class Song`
`def to_s`
`"Song: #{@name}--#{@artist} (#{@duration})"`
`end`
`end`
`aSong = Song.new("Bicylops", "Fleck", 260)`
`aSong.to_s`	»	`"Song: Bicylops--Fleck (260)"`

to_s Method를 재정의

상속~!!!

class KaraokeSong < Song
  def initialize(name, artist, duration, lyrics)
    super(name, artist, duration)
    @lyrics = lyrics
  end
end

상위 함수 호출

`class KaraokeSong < Song`
`# Format ourselves as a string by appending`
`# our lyrics to our parent's #to_s value.`
`def to_s`
`super + " [#{@lyrics}]"`
`end`
`end`
`aSong = KaraokeSong.new("My Way", "Sinatra", 225, "And now, the...")`
`aSong.to_s`	»	`"Song: My Way--Sinatra (225) [And now, the...]"`

변수와 같은 이름의 함수를 정의하여 변수에 접근할 수 있도록 하는 방법

`class Song`
`def name`
`@name`
`end`
`def artist`
`@artist`
`end`
`def duration`
`@duration`
`end`
`end`
`aSong = Song.new("Bicylops", "Fleck", 260)`
`aSong.artist`	»	`"Fleck"`
`aSong.name`	»	`"Bicylops"`
`aSong.duration`	»	`260`

변수 속성 관리 방법

class Song

  attr_reader :name, :artist, :duration
  attr_writer :duration

attr_accessor :something
end

class Method와 Variable

class Song
  @@plays = 0
  def initialize(name, artist, duration)
    @name     = name
    @artist   = artist
    @duration = duration
    @plays    = 0
  end
  def play
    @plays += 1
    @@plays += 1
    "This  song: #@plays plays. Total #@@plays plays."
  end
end

class Example

  def instMeth              # instance method
  end

  def Example.classMeth     # class method
  end

end

`class SongList`
`MaxTime = 5*60 # 5 minutes`

`def SongList.isTooLong(aSong)`
`return aSong.duration > MaxTime`
`end`
`end`

class 접근 제한자

class MyClass

      def method1    # default is 'public'
        #...
      end

  protected          # subsequent methods will be 'protected'

      def method2    # will be 'protected'
        #...
      end

  private            # subsequent methods will be 'private'

      def method3    # will be 'private'
        #...
      end

  public             # subsequent methods will be 'public'

      def method4    # and this will be 'public'
        #...
      end
end

class MyClass

def method1 end # ... and so on public :method1, :method4 protected :method2 private :method3 end

20 프로그래밍 팁

Sun, 23 Oct 2011 13:19:21 +0900

소개

각종 프로그래밍에 대한 팁을 모아놓은 페이지다.

00 포트폴리오(Portfolio)

Sun, 25 Sep 2011 02:41:48 +0900

00 포트폴리오(Protfolio)

수상경력
- 마이크로 소프트 이메진컵 2007 한국 대회 금상 수상(교육부 장관상)
  - Active Sound Maker로 출전
  - http://kkamagui.tistory.com/263
- 경북대학교 Capston Design 2007 대상 수상
  - Upgrade Active Sound Maker로 출전
  - http://kkamagui.tistory.com/263
- 경북대학교 2007 복현배 프로그래밍 경진대회 금상 수상

강사 및 기고
- 2007/09/15 전국 멤버십 사내 교육 강사 - OS Framework를 통해 쉽게 접근하는 Kernel 제작 - 01 OS 프레임워크 참조
- 2008/01 ~ 2008/04 "마이크로 소프트웨어"지 연재 - 프레임워크로 다시보는 OS 개발
- 2008~2010 MINT64 OS(Multicore Intelligent 64bit OS) 개발 및 자료 정리 중
  - http://kkamagui.tistory.com/category/OS%20Kernel/MINT64%20OS
- 2011년 6월 24일 "64비트 멀티코어 OS 원리와 구조" 출간

Operating System Development
- KKAMAGUI OS : 다양한 기능을 갖춘 32Bit 범용 OS. 현재 OS 프레임워크 소스의 기반이 됨
  - http://kkamagui.egloos.com/3071201
  - 01 OS 프레임워크
- KKAMAGUI OS Framework : CPU 및 Hardware에 특화된 부분을 Framework에서 처리해주어 OS 구현 시 초기 작업의 로드를 줄임. OS 개발을 보다 추상화된 환경에서 가능하도록 기반 환경을 제공
  - 01 OS 프레임워크
- ARM Simple OS : 태스크 생성 및 간단한 태스크 스위칭 기능 구현. 멀티 태스킹 정도만 구현
  - 04 NDS 커널(Kernel) 만들기 : ARM9 및 ARM7 듀얼코어를 사용하는 커널. NDS의 주변 장치 중 WIFI 모듈을 제외하고 모두 사용가능
- Embedded System 용 Simple GUI Library : MFC 기반의 Simple GUI Library. NDS에서 사용할 용도로 만듬. 작은 코드지만 나름대로 강력한 기능 제공
  - 02 NDS 윈도우 시스템(Windows System) : NDS ARM9 용 GUI Library

Window System Programming
- 보안 프로그램 분석 및 Bypass : 여러종류의 보안 프로그램을 분석하고 후킹된 부분을 Bypass하여 원하는 기능 복원하는 기능. 분석용 툴 자체 제작
  - 자료의 특성상 비공개
- USB Function 드라이버 제작 : 사이프레스사의 fx2lp 보드와 통신하는 드라이버 제작
- TDI 필터 드라이버 : TDI 드라이버를 후킹하여 유저 레벨 프로그램에서 송수신하는 패킷 모니터링 및 패킷 생성 기능
  - 03 Network Monitor
- Keyboard/Mouse 필터 드라이버 : 키보드 및 마우스의 데이터를 모니터링 및 데이터 생성하는 기능
  - 자료의 특성상 비공개
- Keyboard/Mouse 가상 HID(Virtual HID)드라이버 : HID를 가상으로 생성하여 키보드/마우스 데이터를 생성하는 기능
  - 자료의 특성상 비공개
- SDT 후킹을 이용한 시스템 모니터링 프로그램 : SDT를 후킹하여 특정 파일 접근 및 프로세스 생성 모니터링. 파일 및 폴더 숨김 기능 및 삭제 금지 기능 제공
  - 04 System Monitor
- 파일 시스템 포맷 프로그램 : 이동식 디스크를 디스크 특성에 맞게 각 옵션들을 제어하여 최적의 상태로 포맷해주는 프로그램. FAT 파일 시스템의 모든 옵션 사용 가능
  - 03 File System
- PE File 암호화 : 웜이나 기타 바이러스로 인해 실행파일이 감염되어 실행되는 것을 막고, 실행 파일에 데이터를 숨기기 위한 기능 제공. 실행파일 패킹 툴과 같은 역할
  - 01 PE 파일 분석

ETC Board Programming
- NDSL 홈 브루 개발 : DevKitPro를 이용해서 직접 만든 홈브루 프로그램
- TI DSP c7000, c5000 시리즈 : MP3 Player 포팅 및 기타 유틸리티 제작
  - http://kkamagui.egloos.com/category/ARM%2FDSP%2FNDS%2FUSB
- USB 펌웨어 : 사이프레스사의 fx2lp를 사용하는 간단한 펌웨어 제작

Window Programming
- 전화 제어 서버 프로그램 : PBX(사설 교환기)와 연동하여 전화를 제어하고 이에 대한 정보를 DB에 처리해주는 프로그램. 2006년까지 서울을 제외한 거의 전국(제주도 포함)에서 사용됨.
- 멀티데스크톱 프로그램 : 가상화면을 9개 생성하여 작업 환경을 넓혀주는 역할 및 '항상 위' 기능을 제공하여 특정 창을 항상 위에 위치시키는 기능 제공. 작업 편리를 위해 작성한 프로그램
  - 01 Virtual Desktop
- 일정관리 프로그램 : 기존의 일정관리 프로그램이 일정에 대한 관리가 중심인데, 여기에 파일 관리 기능을 추가하여 파일도 같이 관리할 수 있도록 함. FTP 서버와 연계하여 파일 업로드/다운로드 및 일정 업로드/다운로드 기능 제공
  - 00 KKAMALENDAR(KKAMAGUI Calendar)
- MIDI 분석 및 연주 프로그램: MIDI 파일을 분석하여 템포 및 타이밍을 계산하고 이것을 연주해 주는 프로그램. Raw MIDI 함수 사용했으며 마이크로소프트 이메진컵 2007(Microsoft ImagineCup 2007)에서 금상 수상
  - http://kkamagui.tistory.com/281
  - http://kkamagui.tistory.com/263
- 단축 키를 이용해서 프로그램을 실행하는 프로그램 : 필요에 의해 만들었음. 만들고 나니 나름대로 편함
  - 02 Key Launcher
- 기타 온갖 윈도우 프로그램 : 메신져를 포함한 위에서 언급하지 않은 등등의 프로그램들...

00 KKAMAGUI 소개

Sun, 25 Sep 2011 02:41:23 +0900

이사한 소감

안녕하세요 까마구입니다. ^ㅡ^

지인들의 블로그를 둘러보다가 여기까지 오게 되었네요.

옛날 회사에서 위키를 이용해서 지식관리시스템을 구축했었는데, 그거랑 느낌이 비슷 @0@.

아주 만족스럽습니다. 이제는 이쪽으로 옮겨올까 하는 즐거운 고민이... ㅋㅋ ^ㅡ^)/~~

ps) 아직 긴글 쓰기나 되돌리기 기능은 약간 문제가 있는 듯... ㅡ_ㅡa... 이런.. ㅋㅋ

KKAMAGUI 소개

어렸을 때부터 프로그래밍에 관심이 많았던 철없던 꼬마...

나이가 들어도 철이 없기는 마찬가지지만 프로그래밍에 대한 열정은 나날이 커져서 이제 별로 안해본게 없는 것 같습니다. ㅎㅎ

죽자살자 OS도 만들어보고 윈도우 시스템 프로그래밍도 해보고, 각종 네트워크 어플리케이션도 만들어보고... 그러다가 좋은 사람들... 좋은 스승님도 만나고 ㅎㅎ

지금처럼만 살 수 있다면 얼마나 행복할까요?

좀더 시간이 지나서 회사에 입사하고 정신없이 바쁘면 여러가지가 소흘해 지겠지만... 그래도 프로그래밍에 대한 열정만큼은 잃지 않고 살아갈겁니다.

Written By KKAMAGUI

mint64os@gmail.com

다들 화이팅입니다. @0@)/~

나의 행적...

병역 특례 후(2006 ~ 현재)

윈도우 시스템 프로그래밍 시작. 2006년 후반 처음으로 디바이스 드라이버 파일을 작성해 본 것이 시초였음
윈도우도 디바이스 드라이버를 이용하면 못하는 게 없음을 알게됨
SDT 훅을 이용한 시스템 감시 프로그램 작성
TDI 훅을 이용한 네트워크 모니터링 및 패킷 송신 프로그램 작성
키보드/마우스 필터 드라이버 작성
PE 파일을 보호하기위한 PE 파일 암호화 프로그램 작성
보안 프로그램 분석 및 Bypass 프로그램 작성
유틸리티 프로그램 작성( 토순이, 일정관리 프로그램, 단축키 프로그램 ). 00 포트폴리오(Portfolio)참고
FAT 파일 시스템 포맷 프로그램 작성
각종 파이썬 프로그램 작성
- 간단한 유틸리티 프로그램
NDSL 용 홈브루 작성. 그림판 같은 간단한 메모 프로그램. 02 NDS 및 ARM 참고
"마이크로 소프트웨어"지에 2008년 1월부터 4월까지 "프레임워크로 다시보는 OS 개발" 기사 연재
얼마전(2008년 4월)에 구매한 PSP 흰둥이를 가지고 홈브루 개발 준비중
현재(2008년 1월~) 모사에 근무중
MINT64 OS(Multicore Intelligent 64bit OS) 개발 및 자료 정리 중
- http://kkamagui.tistory.com/category/OS%20Kernel/MINT64%20OS
- http://kkamagui.tistory.com/558
2011년 6월 24일 "64비트 멀티코어 OS 원리와 구조" 출간

병특 시절(2002 ~ 2006 초)

전국 소방본부의 전화 처리 서버 프로그램 제작. 2005년 말까지 서울 소방본부 빼고 거의 모든 지역이 내가 만든 전화 처리 프로그램으로 업무 수행.(상당히 부담.. ㅡ_ㅡ;;;;)
교환기 제어 프로토콜인 CSTA II 프로토콜 학습. CSTA II 프로토콜 전문 업체가 버그를 속출시켜서 나도 모르게 하게됬음( ㅡ_ㅡ;;;; 왜 자꾸 죽는거야... ㅠ_ㅠ)
그 외 무선 장비 및 방송 장비 제어 프로그램 제작. 서버 프로그램의 역할
소방업무 특성상 무휴였기 때문에 서버 프로그램도 죽으면 안됬음. 이때 견고한 프로그램을 짜는 감을 많이 들였음.
TCP/IP 프로그래밍에 대해서는 외울만큼 함
특례 기간 동안 과도한 프로그래밍(?)으로 인해 시스템 전반에 대한 이해가 높아져서 OS 프로그래밍에 도전
"KKAMA OS" 라고 이름붙이고 그후 2년 동안 OS 프로그램 제작. 에드워드 형의 소개를 받아서 kkamagui.osx86.org 도메인을 사용하게 됨.
OS 프로그래밍을 하면서 시스템 프로그래밍에 대한 감을 잡음
KKAMAGUI OS에 대한 내용은 http://kkamagui.egloos.com/3071201 그림 및 01 OS 프레임워크 내용 참조

병특 시절 이전( ~2002)

온 갖 잡다한 프로그래밍
DOS 시절 BIOS Interrupt를 이용하여 320 * 200 모드로 바꿔놓고 PCX 파일을 화면에 뿌리는 삽질
640 * 480 모드 게임용 라이브러리 만든답시고 책(Include)에 있는 코드 다 손으로 치고 고치고 난리도 아니었음
대학교에 입학하여 콘솔 화면용 라인 에디터 개발(이때까지 만든 것 중에 가장 완성도가 높았음)
취미삼아 만들던 MUD(Multi User Dungeon 이었던가...)... 여튼 콘솔용 게임 작성. Linux의 TCP/IP 서버/클라이언트로 동작(이때 이 큰 프로그램을 혼자 짜면서 내가 소질있는 걸 알았다.. ㅋㅋ)
MUD를 Windows API 공부하면서 MFC로 컨버팅. 이때는 GUI 화면으로 구성되었음. 개발하다가 또 하는게 귀찮아서 그만둠
MFC를 배우면서 같은 과에 민종이 형에게 자극받아 메신져 프로그램 개발.분에 넘치는 과도한 프로그래밍으로 버그가 넘침. ㅜ_ㅜ 디버깅이 쉽지 않다는 것을 깨달았음

03 비디오 모드 제어(Video Mode Control)

Tue, 13 Sep 2011 14:14:28 +0900

03 비디오 모드 제어(Video Mode Control)

원문 : http://kkamagui.springnote.com/pages/410834

들어가기 전에...

이 글은 kkamagui에 의해 작성된 글입니다.
마음껏 인용하시거나 사용하셔도 됩니다. 단 출처(http://kkamagui.tistory.com, http://kkamagui.springnote.com)는 밝혀 주십시오.
기타 사항은 mint64os at gmail.com 이나 http://kkamagui.tistory.com으로 보내주시면 반영하겠습니다.
OS 제작에 대한 상세한 내용은 책 "64비트 멀티코어 OS 원리와 구조"를 참고하기 바랍니다.

0.시작하면서...

NDS는 게임기로 제작되어있기 때문에 다양한 비디오 모드가 존재한다. 홈 브루를 개발하기위해서는 자신이 원하는 모드로 설정해야 하는데, 어떤 순서로 해야 하는지 알아보자.

일단 그래픽을 화면에 표시하기 위해서는 LCD를 켜야 한다. LCD를 키는 부분은 파워 컨트롤(Power Control) 부분에서 하는 것이므로 04 파워 컨트롤(Power Control) 문서를 참조하도록 하자.

그래픽쪽 파워를 설정했으면 이제 비디오 모드를 설정해야 한다. http://nocash.emubase.de/gbatek.htm#dsvideo 를 보면 상세하게 나와있으니 참고하고 몇가지 부분만 보자.

참고로 파워 컨트롤에서 나왔지만 LCD Swap이 되지 않은 상태라면 하단 LCD가 Engine A가 되고 상단 LCD가 Engine B가 된다. Engine B는 A보다 약간 모자란데, GBA 게임을 넣으면 상단으로 표시되는걸 봐서 GBA 게임을 돌리기위한 엔진의 역할도 하고 있는 것 같다.

2D Engines
Includes two 2D Engines, called A and B. Both engines are accessed by the ARM9 processor, each using different memory and register addresses:
Region______Engine A______________Engine B___________
  I/O Ports   4000000h              4001000h
  Palette     5000000h (1K)         5000400h (1K)
  BG VRAM     6000000h (max 512K)   6200000h (max 128K)
  OBJ VRAM    6400000h (max 256K)   6600000h (max 128K)
  OAM         7000000h (1K)         7000400h (1K)
Engine A additionally supports 3D and large-screen 256-color Bitmaps, plus main-memory-display and vram-display modes, plus capture unit.

Engine A에는 B에는 없는 3D와 큰 비트맵을 처리할 수 있는 모드, Main Memory를 그대로 Display해주는 모드(프레임 버퍼 모드), 그리고 비디오 화면을 그대로 캡쳐해서 다시 메모리로 저장해주는 캡쳐모드 등등이 있다.

Engine A와 Engine B의 VRAM 최대크기는 각각 512Kbyte 및 128Kbyte라는 것을 알아두자.

BG VRAM 주소와 OBJ VRAM, OAM 주소는 고정되어 있으나 실제 VRAM 주소에 여러가지 VRAM들(VRAM_A, VRAMB, VRAM_C등등)을 맵핑하여 사용하는 방식이며 Video 모드에 따라서 적당한 크기의 VRAM을 맵핑하면 된다.

위에서 잠깐 OAM이라는 생소한 용어가 나오는데, 스프라이트 관련 정보를 저장하는 메모리이다. 게임 제작에 대해서는 큰 비중을 두지 않을 것이므로 그냥 알고 넘어가자.

OAM - Object Attribute Memory
This memory area contains Attributes which specify position, size, color depth, etc. appearance for each of the 128 OBJs. Additionally, it contains 32 OBJ Rotation/Scaling Parameter groups. OAM is located at 07000000-070003FF (sized 1 KByte).

위의 표에서 보면 알 수 있듯이 메인 메모리가 4Mbyte 밖에 안되는 것을 생각해 볼때 꽤 많은 비디오 메모리를 가지고 있는 것을 알 수 있다. 뒤에 비디오 메모리를 어느 LCD에다 맵핑할지를 결정하는 부분이 있는데, 맵핑하고 남은 영역은 데이터 영역으로도 활용 가능할 것 같다.

비디오 모드를 설정하는 과정을 간단히 요약하면 아래와 같다.

Display Control Register를 설정하여 비디오 모드를 설정한다.
VRAMxCNT 레지스터를 이용하여 Video RAM을 MAIN BG Address-Engine A(6000000h), SUB BG Address-Engine B(6200000h)부터 적당히 맵핑해 준다.
BG 모드 사용시 BGxCNT 레지스터를 사용하여 Background의 속성을 설정한다.
비디오 메모리에 쓴다.

아래는 NDS의 Video Memory와 Controller의 관계를 그린것이다.

DS Video Display System Block Diagram

            _____________               __________
  VRAM A -->| 2D Graphics |--------OBJ->|          |
  VRAM B -->| Engine A    |--------BG3->| Layering |
  VRAM C -->|             |--------BG2->| and      |
  VRAM D -->|             |--------BG1->| Special  |
  VRAM E -->|             |   ___       | Effects  |
  VRAM F -->|             |->|SEL|      |          |          ______
  VRAM G -->| - - - - - - |  |BG0|-BG0->|          |----+--->|      |
            | 3D Graphics |->|___|      |__________|    |    |Select|
            | Engine      |                             |    |Video |
            |_____________|--------3D----------------+  |    |Input |
             _______      _______              ___   |  |    |      |
            |       |    |       |<-----------|SEL|<-+  |    |and   |-->
            |       |    |       |    _____   |A  |     |    |      |
  VRAM A <--|Select |    |Select |   |     |<-|___|<----+    |Master|
  VRAM B <--|Capture|<---|Capture|<--|Blend|   ___           |Bright|
  VRAM C <--|Dest.  |    |Source |   |_____|<-|SEL|<----+    |A     |
  VRAM D <--|       |    |       |            |B  |     |    |      |
            |_______|    |_______|<-----------|___|<-+  |    |      |
             _______                                 |  |    |      |
  VRAM A -->|Select |                                |  |    |      |
  VRAM B -->|Display|--------------------------------+------>|      |
  VRAM C -->|VRAM   |                                   |    |      |
  VRAM D -->|_______|   _____________                   |    |      |
                       |Main Memory  |                  |    |      |
  Main   ------DMA---->|Display FIFO |------------------+--->|______|
  Memory               |_____________|
             _____________               __________           ______
  VRAM C -->| 2D Graphics |--------OBJ->| Layering |         |      |
  VRAM D -->| Engine B    |--------BG3->| and      |         |Master|
  VRAM H -->|             |--------BG2->| Special  |-------->|Bright|-->
  VRAM I -->|             |--------BG1->| Effects  |         |B     |
            |_____________|--------BG0->|__________|         |______|

이제 각 파트에 대해서 자세히 알아보자.

1. Display Control

제일 처음 Display Control 레지스터를 설정하여 표시될 모드를 설정해야 한다. http://nocash.emubase.de/gbatek.htm#lcdiodisplaycontrol를 보면 아래와 같이 나와있다(GBA의 LCD Control 설정이다. 일단 비트의 기능은 NDS와 거의 동일하니까 먼저 보자).

1.1 GBA Display Control Register

4000000h - DISPCNT - LCD Control (Read/Write)

Bit   Expl.
  0-2   BG Mode                (0-5=Video Mode 0-5, 6-7=Prohibited)
  3     Reserved for BIOS      (CGB Mode - cannot be changed after startup)
  4     Display Frame Select   (0-1=Frame 0-1) (for BG Modes 4,5 only)
  5     H-Blank Interval Free  (1=Allow access to OAM during H-Blank)
  6     OBJ Character VRAM Mapping (0=Two dimensional, 1=One dimensional)
  7     Forced Blank           (1=Allow access to VRAM,Palette,OAM)
  8     Screen Display BG0  (0=Off, 1=On)
  9     Screen Display BG1  (0=Off, 1=On)
  10    Screen Display BG2  (0=Off, 1=On)
  11    Screen Display BG3  (0=Off, 1=On)
  12    Screen Display OBJ  (0=Off, 1=On)
  13    Window 0 Display Flag   (0=Off, 1=On)
  14    Window 1 Display Flag   (0=Off, 1=On)
  15    OBJ Window Display Flag (0=Off, 1=On)

The table summarizes the facilities of the separate BG modes (video modes).

Mode  Rot/Scal Layers Size               Tiles Colors       Features
  0     No       0123   256x256..512x515   1024  16/16..256/1 SFMABP
  1     Mixed    012-   (BG0,BG1 as above Mode 0, BG2 as below Mode 2)
  2     Yes      --23   128x128..1024x1024 256   256/1        S-MABP
  3     Yes      --2-   240x160            1     32768        --MABP
  4     Yes      --2-   240x160            2     256/1        --MABP
  5     Yes      --2-   160x128            2     32768        --MABP

Features: S)crolling, F)lip, M)osaic, A)lphaBlending, B)rightness, P)riority.

BG Modes 0-2bit

BG Modes 0-2 are Tile/Map-based. BG Modes 3-5 are Bitmap-based, in these modes 1 or 2 Frames (ie. bitmaps, or 'full screen tiles') exists, if two frames exist, either one can be displayed, and the other one can be redrawn in background.

Blanking Bits 5, 7Bit

Setting Forced Blank (Bit 7) causes the video controller to display white lines, and all VRAM, Palette RAM, and OAM may be accessed.
"When the internal HV synchronous counter cancels a forced blank during a display period, the display begins from the beginning, following the display of two vertical lines." What ?
Setting H-Blank Interval Free (Bit 5) allows to access OAM during H-Blank time - using this feature reduces the number of sprites that can be displayed per line.

Screen Display BG Bits 8~12Bit, Window Display Bits 13~14Bit, Object Window Display Bit 15Bit

By default, BG0-3 and OBJ Display Flags (Bit 8-12) are used to enable/disable BGs and OBJ. When enabling Window 0 and/or 1 (Bit 13-14), color special effects may be used, and BG0-3 and OBJ are controlled by the window(s).

Frame Selection 4bit

In BG Modes 4 and 5 (Bitmap modes), either one of the two bitmaps/frames may be displayed (Bit 4), allowing the user to update the other (invisible) frame in background. In BG Mode 3, only one frame exists.
In BG Modes 0-2 (Tile/Map based modes), a similar effect may be gained by altering the base address(es) of BG Map and/or BG Character data.

4000002h - Undocumented - Green Swap (R/W)

Normally, red green blue intensities for a group of two pixels is output as BGRbgr (uppercase for left pixel at even xloc, lowercase for right pixel at odd xloc). When the Green Swap bit is set, each pixel group is output as BgRbGr (ie. green intensity of each two pixels exchanged).
  Bit   Expl.
  0     Green Swap  (0=Normal, 1=Swap)
  1-15  Not used

This feature appears to be applied to the final picture (ie. after mixing the separate BG and OBJ layers). Eventually intended for other display types (with other pin-outs). With normal GBA hardware it is just producing an interesting dirt effect.
The NDS DISPCNT registers are 32bit (4000000h..4000003h), so Green Swap doesn't exist in NDS mode, however, the NDS does support Green Swap in GBA mode.

1.2 NDS Display Control Register

이제 본격적으로 NDS에 대해서 알아보자. GBA와 비교해서 같은 이름의 비트는 거의 같은 일을 하므로 GBA의 정보와 같이 비교해서 보자.

DS DISPCNT

Bit  Engine Expl.
  0-2   A+B   BG Mode
  3     A     BG0 2D/3D Selection (instead CGB Mode) (0=2D, 1=3D)
  4     A+B   Tile OBJ Mapping        (0=2D; max 32KB, 1=1D; max 32KB..256KB)
  5     A+B   Bitmap OBJ 2D-Dimension (0=128x512 dots, 1=256x256 dots)
  6     A+B   Bitmap OBJ Mapping      (0=2D; max 128KB, 1=1D; max 128KB..256KB)
  7     Forced Blank           (1=Allow access to VRAM,Palette,OAM)
  8     Screen Display BG0  (0=Off, 1=On)
  9     Screen Display BG1  (0=Off, 1=On)
  10    Screen Display BG2  (0=Off, 1=On)
  11    Screen Display BG3  (0=Off, 1=On)
  12    Screen Display OBJ  (0=Off, 1=On)
  13    Window 0 Display Flag   (0=Off, 1=On)
  14    Window 1 Display Flag   (0=Off, 1=On)
  15    OBJ Window Display Flag (0=Off, 1=On)
  16-17 A+B   Display Mode (Engine A: 0..3, Engine B: 0..1, GBA: Green Swap)
  18-19 A     VRAM block (0..3=VRAM A..D) (For Capture & above Display Mode=2)
  20-21 A+B   Tile OBJ 1D-Boundary   (see Bit4)
  22    A     Bitmap OBJ 1D-Boundary (see Bit5-6)
  23    A+B   OBJ Processing during H-Blank (was located in Bit5 on GBA)
  24-26 A     Character Base (in 64K steps) (merged with 16K step in BGxCNT)
  27-29 A     Screen Base (in 64K steps) (merged with 2K step in BGxCNT)
  30    A+B   BG Extended Palettes   (0=Disable, 1=Enable)
  31    A+B   OBJ Extended Palettes  (0=Disable, 1=Enable)

BG Mode

Engine A BG Mode (DISPCNT LSBs) (0-6, 7=Reserved), Engine B도 5번까지는 같음
  Mode  BG0      BG1      BG2      BG3
  0     Text/3D  Text     Text     Text
  1     Text/3D  Text     Text     Affine
  2     Text/3D  Text     Affine   Affine
  3     Text/3D  Text     Text     Extended
  4     Text/3D  Text     Affine   Extended
  5     Text/3D  Text     Extended Extended
  6     3D       -        Large    -
Extended 모드는 Backgound 속성과 함께 다시 세부 모드로 나누어 진다. 즉 위의 GBA 모드와는 다르다.

Of which, the "Extended" modes are sub-selected by BGxCNT bits:

(BGxCNT.Bit7은 Colors/Palettes Bit이고 , Bit2는 Character Base Block의 첫번째 bit이다)
  BGxCNT.Bit7 BGxCNT.Bit2 Extended Affine Mode Selection
  0           CharBaseLsb rot/scal with 16bit bgmap entries (Text+Affine mixup)
  1           0           rot/scal 256 color bitmap
  1           1           rot/scal direct color bitmap
direct color bitmap 모드를 사용하면 R/G/B 각각이 5bit이고 Alpha가 1bit인 Color Mode를 사용할 수 있다. 뒤에서 이 모드를 이용하여 프레임 버퍼 모드와 비슷하게 설정할 것이다.

Engine B: Same as above, except that: Mode 6 is reserved (no Large screen bitmap), and BG0 is always Text (no 3D support).

Affine = formerly Rot/Scal mode (with 8bit BG Map entries)
Large Screen Bitmap = rot/scal 256 color bitmap (using all 512K of 2D VRAM)

Display Mode (DISPCNT.16-17):
0  Display off (screen becomes white)
  1  Graphics Display (normal BG and OBJ layers)
  2  Engine A only: VRAM Display (Bitmap from block selected in DISPCNT.18-19)
  3  Engine A only: Main Memory Display (Bitmap DMA transfer from Main RAM)
Mode 2-3 display a raw direct color bitmap (15bit RGB values, the upper bit in each halfword is unused), without any further BG,OBJ,3D layers, these modes are completely bypassing the 2D/3D engines as well as any 2D effects, however the Master Brightness effect can be applied to these modes. Mode 2 is particulary useful to display captured 2D/3D images (in that case it can indirectly use the 2D/3D engine).

BGxCNT
character base extended from bit2-3 to bit2-5 (bit4-5 formerly unused)

character base is used only in tile/map modes (not bitmap modes)

screen base is used in tile/map modes, screen base used in bitmap modes as BGxCNT.bits*16K, without DISPCNT.bits*64K
engine A screen base: BGxCNT.bits*2K + DISPCNT.bits*64K
  engine B screen base: BGxCNT.bits*2K + 0
  engine A char base: BGxCNT.bits*16K + DISPCNT.bits*64K
  engine B char base: BGxCNT.bits*16K + 0
engine A bitmap screen base: BGxCNT.bit*16K + 0
  engine B bitmap screen base: BGxCNT.bit*16K + 0 
위와 같이 Bitmap 모드일 경우 Offset은 16K가 곱해진다. 이것을 잘 기억해 두면 Double Buffering을 할 때 잘 사용할 수 있다.

screen base however NOT used at all for Large screen bitmap mode
bgcnt sc.size  text     rotscal    bitmap   large bmp
  0              256x256  128x128    128x128  512x1024
  1              512x256  256x256    256x256  1024x512
  2              256x512  512x512    512x256  -
  3              512x512  1024x1024  512x512  -
bitmaps that require more than 128K VRAM are supported on engine A only.

For BGxCNT.Bit7 and BGxCNT.Bit2 in Extended Affine modes, see above BG Mode description (extended affine doesn't include 16-color modes, so color depth bit can be used for mode selection. Also, bitmap modes do not use charbase, so charbase.0 can be used for mode selection as well).

for BG0, BG1 only: bit13 selects extended palette slot
(BG0: 0=Slot0, 1=Slot2, BG1: 0=Slot1, 1=Slot3)
Direct Color Bitmap BG, and Direct Color Bitmap OBJ
BG/OBJ Supports 32K colors (15bit RGB value) - so far same as GBAs BG.
However, the upper bit (Bit15) is used as Alpha flag. That is, Alpha=0=Transparent, Alpha=1=Normal (ie. on the NDS, Direct Color values 0..7FFFh are NOT displayed).

위에서 BGxCNT 레지스터에 대한 설정이 잠깐 나왔는데, Background(BG) 모드를 사용하면 해당 BG에 대한 설정을 해줘야 한다. 자세한 내용은 다음 섹션에서 알아보자

아래는 Charactor(Bitmap)/Screen 모드에 따른 Offset 별 주소 공간을 나타낸 것이다. http://www.dev-scene.com/NDS/Tutorials_Day_3를 보면 잘 나와있다.

1.3 BG Mode Detail

위에서 보면 BG 모드에 따라서 BG 0~3의 용도가 달라졌다. 이제 좀더 자세하게 알아보자. 이 부분에 대한 자세한 내용은 http://nocash.emubase.de/gbatek.htm#lcdvramoverview에서 찾을 수 있다.

BG Mode 0,1,2 (Tile/Map based Modes)
06000000-0600FFFF  64 KBytes shared for BG Map and Tiles
  06010000-06017FFF  32 KBytes OBJ Tiles
The shared 64K area can be split into BG Map area(s), and BG Tiles area(s), the respective addresses for Map and Tile areas are set up by BG0CNT-BG3CNT registers. The Map address may be specified in units of 2K (steps of 800h), the Tile address in units of 16K (steps of 4000h).

BG Mode의 0~2 모드는 위와 같이 영역이 정해진다.

BG Mode 0,1 (Tile/Map based Text mode)
The tiles may have 4bit or 8bit color depth, minimum map size is 32x32 tiles, maximum is 64x64 tiles, up to 1024 tiles can be used per map.
Item        Depth     Required Memory
  One Tile    4bit      20h bytes
  One Tile    8bit      40h bytes
  1024 Tiles  4bit      8000h (32K)
  1024 Tiles  8bit      10000h (64K) - excluding some bytes for BG map
  BG Map      32x32     800h (2K)
  BG Map      64x64     2000h (8K)
BG Mode 1,2 (Tile/Map based Rotation/Scaling mode)
The tiles may have 8bit color depth only, minimum map size is 16x16 tiles, maximum is 128x128 tiles, up to 256 tiles can be used per map.

BG Mode 3 (Bitmap based Mode for still images)
06000000-06013FFF  80 KBytes Frame 0 buffer (only 75K actually used)
  06014000-06017FFF  16 KBytes OBJ Tiles
BG Mode 4,5 (Bitmap based Modes)
06000000-06009FFF  40 KBytes Frame 0 buffer (only 37.5K used in Mode 4)
  0600A000-06013FFF  40 KBytes Frame 1 buffer (only 37.5K used in Mode 4)
  06014000-06017FFF  16 KBytes OBJ Tiles
Note
Additionally to the above VRAM, the GBA also contains 1 KByte Palette RAM (at 05000000h) and 1 KByte OAM (at 07000000h) which are both used by the display controller as well.

위에서 3,4,5와 같은 경우는 우리가 흔히 사용하는 프레임 버퍼모드와 비슷하게 동작하게 만들 수 있다. 단 Direct Color 모드를 사용해야 하는데, Direct Color 모드일 경우 R/G/B 각각 5bit와 Alpha 1bit로 이루어지는 차이 밖에 없다.

각 BG 모드에 따라서 위와 같이 사용된다. 좀 더 자세한 내용은 아래와 같다.

LCD VRAM Character Data

Each character (tile) consists of 8x8 dots (64 dots in total). The color depth may be either 4bit or 8bit (see BG0CNT-BG3CNT).

4bit depth (16 colors, 16 palettes)

Each tile occupies 32 bytes of memory(왜? 8*8*4bit니까), the first 4 bytes for the topmost row of the tile, and so on. Each byte representing two dots, the lower 4 bits define the color for the left dot, the upper 4 bits the color for the right dot.

8bit depth (256 colors, 1 palette)
Each tile occupies 64 bytes of memory(왜? 8*8*8bit니까), the first 8 bytes for the topmost row of the tile, and so on. Each byte selects the palette entry for each dot.

LCD VRAM BG Screen Data Format (BG Map)

The display background consists of 8x8 dot tiles, the arrangement of these tiles is specified by the BG Screen Data (BG Map). The separate entries in this map are as follows:

Text BG Screen (2 bytes per entry)
Specifies the tile number and attributes. Note that BG tile numbers are always specified in steps of 1 (unlike OBJ tile numbers which are using steps of two in 256 color/1 palette mode).
  Bit   Expl.
  0-9   Tile Number     (0-1023) (a bit less in 256 color mode, because
                           there'd be otherwise no room for the bg map)
  10    Horizontal Flip (0=Normal, 1=Mirrored)
  11    Vertical Flip   (0=Normal, 1=Mirrored)
  12-15 Palette Number  (0-15)    (Not used in 256 color/1 palette mode)
A Text BG Map always consists of 32x32 entries (256x256 pixels), 400h entries = 800h bytes. However, depending on the BG Size, one, two, or four of these Maps may be used together, allowing to create backgrounds of 256x256, 512x256, 256x512, or 512x512 pixels, if so, the first map (SC0) is located at base+0, the next map (SC1) at base+800h, and so on.

Rotation/Scaling BG Screen (1 byte per entry)
In this mode, only 256 tiles can be used. There are no x/y-flip attributes, the color depth is always 256 colors/1 palette.
Bit   Expl.
  0-7   Tile Number     (0-255)
The dimensions of Rotation/Scaling BG Maps depend on the BG size. For size 0-3 that are: 16x16 tiles (128x128 pixels), 32x32 tiles (256x256 pixels), 64x64 tiles (512x512 pixels), or 128x128 tiles (1024x1024 pixels).
The size and VRAM base address of the separate BG maps for BG0-3 are set up by BG0CNT-BG3CNT registers.

LCD VRAM Bitmap BG Modes

In BG Modes 3-5 the background is defined in form of a bitmap (unlike as for Tile/Map based BG modes). Bitmaps are implemented as BG2, with Rotation/Scaling support. As bitmap modes are occupying 80KBytes of BG memory, only 16KBytes of VRAM can be used for OBJ tiles.

BG Mode 3 - 240x160 pixels, 32768 colors
Two bytes are associated to each pixel, directly defining one of the 32768 colors (without using palette data, and thus not supporting a 'transparent' BG color).
Bit   Expl.
  0-4   Red Intensity   (0-31)
  5-9   Green Intensity (0-31)
  10-14 Blue Intensity  (0-31)
  15    Not used
The first 480 bytes define the topmost line, the next 480 the next line, and so on. The background occupies 75 KBytes (06000000-06012BFF), most of the 80 Kbytes BG area, not allowing to redraw an invisible second frame in background, so this mode is mostly recommended for still images only.

BG Mode 4 - 240x160 pixels, 256 colors (out of 32768 colors)
One byte is associated to each pixel, selecting one of the 256 palette entries. Color 0 (backdrop) is transparent, and OBJs may be displayed behind the bitmap.
The first 240 bytes define the topmost line, the next 240 the next line, and so on. The background occupies 37.5 KBytes, allowing two frames to be used (06000000-060095FF for Frame 0, and 0600A000-060135FF for Frame 1).

BG Mode 5 - 160x128 pixels, 32768 colors
Colors are defined as for Mode 3 (see above), but horizontal and vertical size are cut down to 160x128 pixels only - smaller than the physical dimensions of the LCD screen.
The background occupies exactly 40 KBytes, so that BG VRAM may be split into two frames (06000000-06009FFF for Frame 0, and 0600A000-06013FFF for Frame 1).

In BG modes 4,5, one Frame may be displayed (selected by DISPCNT Bit 4), the other Frame is invisible and may be redrawn in background.

Frame이 1개 이상일 경우는 Display Control Register의 Bit4에 값을 설정함으로써 현재 표시되는 부분을 바꿀 수 있다.

1.4 Object

Object에 대한 자세한 내용은 http://nocash.emubase.de/gbatek.htm#lcdobjoverview를 보자.

2. VRAM Control

Display 모드를 선택했으니 이제 적당한 크기에 맞는 VRAM을 각 주소로 맵핑을 시켜야 한다. VRAM 제어에 대한 내용은 http://nocash.emubase.de/gbatek.htm#dsmemorycontrolvram에서 살펴볼 수 있다.

4000240h - NDS7 - VRAMSTAT - 8bit - VRAM Bank Status (R)
0     VRAM C enabled and allocated to NDS7  (0=No, 1=Yes)
  1     VRAM D enabled and allocated to NDS7  (0=No, 1=Yes)
  2-7   Not used (always zero)
The register indicates if VRAM C/D are allocated to NDS7 (as Work RAM), ie. if VRAMCNT_C/D are enabled (Bit7=1), with MST=2 (Bit0-2). However, it does not reflect the OFS value.

위 레지스터는 VRAM C와 D가 ARM7에서 WRAM의 용도로 사용가능한가를 나타내는 레지스터이다.

2.1 VRAM의 종류 및 컨트롤 모드

실제로 VRAM Control 레지스터는 8bit로 되어있으며 아래와 같다.

4000240h - VRAMCNT_A - 8bit - VRAM-A (128K) Bank Control (W)
4000241h - VRAMCNT_B - 8bit - VRAM-B (128K) Bank Control (W)
4000242h - VRAMCNT_C - 8bit - VRAM-C (128K) Bank Control (W)
4000243h - VRAMCNT_D - 8bit - VRAM-D (128K) Bank Control (W)
4000244h - VRAMCNT_E - 8bit - VRAM-E (64K) Bank Control (W)
4000245h - VRAMCNT_F - 8bit - VRAM-F (16K) Bank Control (W)
4000246h - VRAMCNT_G - 8bit - VRAM-G (16K) Bank Control (W)
4000248h - VRAMCNT_H - 8bit - VRAM-H (32K) Bank Control (W)
4000249h - VRAMCNT_I - 8bit - VRAM-I (16K) Bank Control (W)
0-2   VRAM MST              ;Bit2 not used by VRAM-A,B,H,I
  3-4   VRAM Offset (0-3)     ;Offset not used by VRAM-E,H,I
  5-6   Not used
  7     VRAM Enable (0=Disable, 1=Enable)
There is a total of 656KB of VRAM in Blocks A-I.

Notes

In Plain-CPU modes :

VRAM can be accessed only by the CPU (and by the Capture Unit, and by VRAM Display mode). In "Plain <ARM7>-CPU Access" mode, the VRAM blocks are allocated as Work RAM to the NDS7 CPU.

In BG/OBJ VRAM modes :

VRAM can be accessed by the CPU at specified addresses, and by the display controller.

In Extended Palette and Texture Image/Palette modes :

VRAM is not mapped to CPU address space, and can be accessed only by the display controller (so, to initialize or change the memory, it should be temporarily switched to Plain-CPU mode).

All VRAM (and Palette, and OAM) can be written to only in 16bit and 32bit units (STRH, STR opcodes), 8bit writes are ignored (by STRB opcode). The only exception is "Plain <ARM7>-CPU Access" mode: The ARM7 CPU can use STRB to write to VRAM (the reason for this special feature is that, in GBA mode, two 128K VRAM blocks are used to emulate the GBA's 256K Work RAM).

2.2 세부 모드별 VRAM 설정

Plain ARM9-CPU Access (so-called LCDC mode)
    VRAM    SIZE MST OFS   ARM9
    A       128K 0    -     6800000h-681FFFFh
    B       128K 0    -     6820000h-683FFFFh
    C       128K 0    -     6840000h-685FFFFh
    D       128K 0    -     6860000h-687FFFFh
    E       64K   0    -     6880000h-688FFFFh
    F       16K   0    -     6890000h-6893FFFh
    G       16K   0    -     6894000h-6897FFFh
    H       32K   0    -     6898000h-689FFFFh
    I       16K   0    -     68A0000h-68A3FFFh
ARM9 2D Graphics Engine A, BG-VRAM (max 512K)
    VRAM    SIZE MST OFS
    A,B,C,D 128K 1    0..3 6000000h+(20000h*OFS)
    E       64K   1    -     6000000h
    F,G     16K   1    0..3 6000000h+(4000h*OFS.0)+(10000h*OFS.1)
ARM9 2D Graphics Engine A, OBJ-VRAM (max 256K)
    VRAM    SIZE MST OFS
    A,B     128K 2    0..1 6400000h+(20000h*OFS.0) ;(OFS.1 must be zero)
    E       64K   2    -     6400000h
    F,G     16K   2    0..3 6400000h+(4000h*OFS.0)+(10000h*OFS.1)
2D Graphics Engine A, BG Extended Palette
    VRAM    SIZE MST OFS
    E       64K   4    -     Slot 0-3 ;only lower 32K used
    F,G     16K   4    0..1 Slot 0-1 (OFS=0), Slot 2-3 (OFS=1)
2D Graphics Engine A, OBJ Extended Palette
VRAM SIZE MST OFS
F,G 16K 5 - Slot 0 ;16K each (only lower 8K used)
Texture/Rear-plane Image
VRAM SIZE MST OFS
A,B,C,D 128K 3 0..3 Slot OFS(0-3) ;(Slot2-3: Texture, or Rear-plane)
Texture Palette
   VRAM    SIZE MST OFS
    E       64K   3    -     Slots 0-3                 ;OFS=don't care
    F,G     16K   3    0..3 Slot (OFS.0*1)+(OFS.1*4) ;ie. Slot 0, 1, 4, or 5
ARM9, 2D Graphics Engine B, BG-VRAM (max 128K)
    VRAM    SIZE MST OFS
    C       128K 4    -     6200000h
    H       32K   1    -     6200000h
    I       16K   1    -     6208000h
ARM9, 2D Graphics Engine B, OBJ-VRAM (max 128K)
    VRAM    SIZE MST OFS
    D       128K 4    -     6600000h
    I       16K   2    -     6600000h
2D Graphics Engine B, BG Extended Palette
VRAM SIZE MST OFS
H 32K 2 - Slot 0-3
2D Graphics Engine B, OBJ Extended Palette
VRAM SIZE MST OFS
I 16K 3 - Slot 0 ;(only lower 8K used)
<ARM7>, Plain <ARM7>-CPU Access
VRAM SIZE MST OFS
C,D 128K 2 0..1 6000000h+(20000h*OFS.0) ;OFS.1 must be zero

위에서 보면 Engine A가 확실히 B보다는 VRAM 선택권이 넓다는 것을 알 수 있다. 그리고 Engine A의 경우는 최대 512Kbyte까지 맵핑 가능하며 Engine B의 경우 최대 128Kbyte까지 맵핑이 가능하다.

이렇게 맵핑이 끝나고 나면 Background Control Register를 통해서 해당 Background에 대한 설정을 해줘야 한다.

3. Background Control

3.1 Background Control Register

Display Control Register를 통해서 원하는 Display 모드를 설정했으면 그에 따른 부수적인 처리를 해줘야 한다. Background 모드(BG)를 이용할 경우 해당 BG를 어떻게 사용할 것인지에 대한 처리를 해야 하는데 자세한 내용은 http://nocash.emubase.de/gbatek.htm#lcdiobgcontrol 를 참고하고 몇가지만 보자.

4000008h - BG0CNT - BG0 Control (R/W)
400000Ah - BG1CNT - BG1 Control (R/W)
400000Ch - BG2CNT - BG2 Control (R/W)
400000Eh - BG3CNT - BG3 Control (R/W)
Bit   Expl.
  0-1   BG Priority           (0-3, 0=Highest)
  2-3   Character Base Block  (0-3, in units of 16 KBytes) (=BG Tile Data)
  4-5   Not used (must be zero)
  6     Mosaic                (0=Disable, 1=Enable)
  7     Colors/Palettes       (0=16/16, 1=256/1)
  8-12  Screen Base Block     (0-31, in units of 2 KBytes) (=BG Map Data)
  13    Display Area Overflow (0=Transparent, 1=Wraparound; BG2CNT/BG3CNT only)
  14-15 Screen Size (0-3)
In case that some or all BGs are set to same priority then BG0 is having the highest, and BG3 the lowest priority.

위의 Display Control에서 보았던 Character Base Block에 대한 영역과 Screen Base Block에 대한 영역값을 볼 수 있다. 그리고 특이한 것이 Display Area를 넘어갈때 그것을 어떻게 처리할 것인지에 대한 설정도 나와있다. Transparent는 아무 것도 안하는 것 같고 Warparound는 넘어선 부분을 다시 0 Base로 하여서 덮어쓰는것 같다.

Internal Screen Size (dots) and size of BG Map (bytes):
Value  Text Mode      Rotation/Scaling Mode
  0      256x256 (2K)   128x128   (256 bytes)
  1      512x256 (4K)   256x256   (1K)
  2      256x512 (4K)   512x512   (4K)
  3      512x512 (8K)   1024x1024 (16K)
In 'Text Modes', the screen size is organized as follows:

The screen consists of one or more 256x256 pixel (32x32 tiles) areas. When Size=0: only 1 area (SC0), when Size=1 or Size=2: two areas (SC0,SC1 either horizontally or vertically arranged next to each other), when Size=3: four areas (SC0,SC1 in upper row, SC2,SC3 in lower row). Whereas SC0 is defined by the normal BG Map base address (Bit 8-12 of BG#CNT), SC1 uses same address +2K, SC2 address +4K, SC3 address +6K. When the screen is scrolled it'll always wraparound.

In 'Rotation/Scaling Modes', the screen size is organized as follows:

only one area (SC0) of variable size 128x128..1024x1024 pixels (16x16..128x128 tiles) exists (SC0). When the screen is rotated/scaled (or scrolled?) so that the LCD viewport reaches outside of the background/screen area, then BG may be either displayed as transparent or wraparound (Bit 13 of BG#CNT).

3.2 Background Scrolling Register

위에서 Background Mode에 대해서 설정했으면 Scrolling에 대한 처리를 해야한다. Scrolling은 큰 Bitmap을 그려놓고 해당 Bitmap내에서 일부분을 화면에 표시할때 유용하게 사용할 수 있다. Scrolling에 대한 자세한 내용은 http://nocash.emubase.de/gbatek.htm#lcdiobgscrolling를 보도록 하자.

4000010h - BG0HOFS - BG0 X-Offset (W)
4000012h - BG0VOFS - BG0 Y-Offset (W)
Bit   Expl.
  0-8   Offset (0-511)
  9-15  Not used
Specifies the coordinate of the upperleft first visible dot of BG0 background layer, ie. used to scroll the BG0 area.

4000014h - BG1HOFS - BG1 X-Offset (W)
4000016h - BG1VOFS - BG1 Y-Offset (W)
Same as above BG0HOFS and BG0VOFS for BG1 respectively.

4000018h - BG2HOFS - BG2 X-Offset (W)
400001Ah - BG2VOFS - BG2 Y-Offset (W)
Same as above BG0HOFS and BG0VOFS for BG2 respectively.

400001Ch - BG3HOFS - BG3 X-Offset (W)
400001Eh - BG3VOFS - BG3 Y-Offset (W)
Same as above BG0HOFS and BG0VOFS for BG3 respectively.

The above BG scrolling registers are exclusively used in Text modes, ie. for all layers in BG Mode 0, and for the first two layers in BG mode .
In other BG modes (Rotation/Scaling and Bitmap modes) above registers are ignored. Instead, the screen may be scrolled by modifying the BG Rotation/Scaling Reference Point registers.

위의 레지스터 설명을 보면 BG Layer에서 표시될 위치를 찍는 것임을 알 수 있다. 하지만 정상적으로 사용하기 위해서는 Text Mode 일때만 가능하다고 되어있다. 다른 모드에서는 Rotation/Scaling을 사용하라는 것인데, 나중에 확실히 테스트 해봐야겠다.

3.3 Background Rotation/Scaling Register

Text 모드가 아닌 경우 스크롤및 화면에 사용될 수 있다. 자세한 내용은 http://nocash.emubase.de/gbatek.htm#lcdiobgrotationscaling을 살펴보자.

4000028h - BG2X_L - BG2 Reference Point X-Coordinate, lower 16 bit (W)
400002Ah - BG2X_H - BG2 Reference Point X-Coordinate, upper 12 bit (W)
400002Ch - BG2Y_L - BG2 Reference Point Y-Coordinate, lower 16 bit (W)
400002Eh - BG2Y_H - BG2 Reference Point Y-Coordinate, upper 12 bit (W)

These registers are replacing the BG scrolling registers which are used for Text mode, ie. the X/Y coordinates specify the source position from inside of the BG Map/Bitmap of the pixel to be displayed at upper left of the GBA display. The normal BG scrolling registers are ignored in Rotation/Scaling and Bitmap modes.
Bit   Expl.
  0-7   Fractional portion (8 bits)
  8-26  Integer portion    (19 bits)
  27    Sign               (1 bit)
  28-31 Not used
Because values are shifted left by eight, fractional portions may be specified in steps of 1/256 pixels (this would be relevant only if the screen is actually rotated or scaled). Normal signed 32bit values may be written to above registers (the most significant bits will be ignored and the value will be cut-down to 28bits, but this is no actual problem because signed values have set all MSBs to the same value).

Internal Reference Point Registers

The above reference points are automatically copied to internal registers during each vblank, specifying the origin for the first scanline. The internal registers are then incremented by dmx and dmy after each scanline.
Caution: Writing to a reference point register by software outside of the Vblank period does immediately copy the new value to the corresponding internal register, that means: in the current frame, the new value specifies the origin of the <current> scanline (instead of the topmost scanline).

4000020h - BG2PA - BG2 Rotation/Scaling Parameter A (alias dx) (W)
4000022h - BG2PB - BG2 Rotation/Scaling Parameter B (alias dmx) (W)
4000024h - BG2PC - BG2 Rotation/Scaling Parameter C (alias dy) (W)
4000026h - BG2PD - BG2 Rotation/Scaling Parameter D (alias dmy) (W)
Bit   Expl.
  0-7   Fractional portion (8 bits)
  8-14  Integer portion    (7 bits)
  15    Sign               (1 bit)

400003Xh - BG3X_L/H, BG3Y_L/H, BG3PA-D - BG3 Rotation/Scaling Parameters

Same as above BG2 Reference Point, and Rotation/Scaling Parameters, for BG3 respectively.

위의 dx, dmx, dy, dmy에 대한 내용은 아래에 나온다.

dx (PA) and dy (PC)

When transforming a horizontal line, dx and dy specify the resulting gradient and magnification for that line. For example:
Horizontal line, length=100, dx=1, and dy=1. The resulting line would be drawn at 45 degrees, f(y)=1/1*x. Note that this would involve that line is magnified, the new length is SQR(100^2+100^2)=141.42. Yup, exactly - that's the old a^2 + b^2 = c^2 formula.

dmx (PB) and dmy (PD)

These values define the resulting gradient and magnification for transformation of vertical lines. However, when rotating a square area (which is surrounded by horizontal and vertical lines), then the desired result should be usually a rotated <square> area (ie. not a parallelogram, for example).
Thus, dmx and dmy must be defined in direct relationship to dx and dy, taking the example above, we'd have to set dmx=-1, and dmy=1, f(x)=-1/1*y.

Area Overflow

In result of rotation/scaling it may often happen that areas outside of the actual BG area become moved into the LCD viewport. Depending of the Area Overflow bit (BG2CNT and BG3CNT, Bit 13) these areas may be either displayed (by wrapping the BG area), or may be displayed transparent.
This works only in BG modes 1 and 2. The area overflow is ignored in Bitmap modes (BG modes 3-5), the outside of the Bitmaps is always transparent.

--- more details and confusing or helpful formulas ---

The following parameters are required for Rotation/Scaling
Rotation Center X and Y Coordinates (x0,y0)
  Rotation Angle                      (alpha)
  Magnification X and Y Values        (xMag,yMag)
The display is rotated by 'alpha' degrees around the center.
The displayed picture is magnified by 'xMag' along x-Axis (Y=y0) and 'yMag' along y-Axis (X=x0).

Calculating Rotation/Scaling Parameters A-D
A = Cos (alpha) / xMag    ;distance moved in direction x, same line
  B = Sin (alpha) / xMag    ;distance moved in direction x, next line
  C = Sin (alpha) / yMag    ;distance moved in direction y, same line
  D = Cos (alpha) / yMag    ;distance moved in direction y, next line
Calculating the position of a rotated/scaled dot
Using the following expressions,
x0,y0    Rotation Center
  x1,y1    Old Position of a pixel (before rotation/scaling)
  x2,y2    New position of above pixel (after rotation scaling)
  A,B,C,D  BG2PA-BG2PD Parameters (as calculated above)
the following formula can be used to calculate x2,y2:
x2 = A(x1-x0) + B(y1-y0) + x0
  y2 = C(x1-x0) + D(y1-y0) + y0

꽤나 복잡한 공식이 있는데, 역시나 게임을 만들진 않을 것이므로 간단히 보고 넘어가자. 뒤에 위에서 나온 것들을 종합하여 프레임 버퍼 모드와 비슷하게 만드는 부분을 볼텐데 그것을 참고자하.

4. Window Register

Window는 스크린을 네개의 영역으로 나눌때 사용된다는데, 자세한 내용은 해보지 않아서 잘 모르겠다. 나중에 테스트 후에 넣도록 하자. 일단 Window에 대한 설명은 http://nocash.emubase.de/gbatek.htm#lcdiowindowfeature에 나와있으니 참고하자.

The Window Feature may be used to split the screen into four regions. The BG0-3,OBJ layers and Color Special Effects can be separately enabled or disabled in each of these regions.

The DISPCNT Register
DISPCNT Bits 13-15 are used to enable Window 0, Window 1, and/or OBJ Window regions, if any of these regions is enabled then the "Outside of Windows" region is automatically enabled, too.
DISPCNT Bits 8-12 are kept used as master enable bits for the BG0-3,OBJ layers, a layer is displayed only if both DISPCNT and WININ/OUT enable bits are set.

4000040h - WIN0H - Window 0 Horizontal Dimensions (W)
4000042h - WIN1H - Window 1 Horizontal Dimensions (W)
Bit   Expl.
  0-7   X2, Rightmost coordinate of window, plus 1
  8-15  X1, Leftmost coordinate of window
Garbage values of X2>240 or X1>X2 are interpreted as X2=240.

4000044h - WIN0V - Window 0 Vertical Dimensions (W)
4000046h - WIN1V - Window 1 Vertical Dimensions (W)
Bit   Expl.
  0-7   Y2, Bottom-most coordinate of window, plus 1
  8-15  Y1, Top-most coordinate of window
Garbage values of Y2>160 or Y1>Y2 are interpreted as Y2=160.

4000048h - WININ - Control of Inside of Window(s) (R/W)
Bit   Expl.
  0-3   Window 0 BG0-BG3 Enable Bits     (0=No Display, 1=Display)
  4     Window 0 OBJ Enable Bit          (0=No Display, 1=Display)
  5     Window 0 Color Special Effect    (0=Disable, 1=Enable)
  6-7   Not used
  8-11  Window 1 BG0-BG3 Enable Bits     (0=No Display, 1=Display)
  12    Window 1 OBJ Enable Bit          (0=No Display, 1=Display)
  13    Window 1 Color Special Effect    (0=Disable, 1=Enable)
  14-15 Not used
400004Ah - WINOUT - Control of Outside of Windows & Inside of OBJ Window (R/W)
Bit   Expl.
  0-3   Outside BG0-BG3 Enable Bits      (0=No Display, 1=Display)
  4     Outside OBJ Enable Bit           (0=No Display, 1=Display)
  5     Outside Color Special Effect     (0=Disable, 1=Enable)
  6-7   Not used
  8-11  OBJ Window BG0-BG3 Enable Bits   (0=No Display, 1=Display)
  12    OBJ Window OBJ Enable Bit        (0=No Display, 1=Display)
  13    OBJ Window Color Special Effect  (0=Disable, 1=Enable)
  14-15 Not used
The OBJ Window
The dimension of the OBJ Window is specified by OBJs which are having the "OBJ Mode" attribute being set to "OBJ Window". Any non-transparent dots of any such OBJs are marked as OBJ Window area. The OBJ itself is not displayed.
The color, palette, and display priority of these OBJs are ignored. Both DISPCNT Bits 12 and 15 must be set when defining OBJ Window region(s).

Window Priority
In case that more than one window is enabled, and that these windows do overlap, Window 0 is having highest priority, Window 1 medium, and Obj Window lowest priority. Outside of Window is having zero priority, it is used for all dots which are not inside of any window region.

5. 사용 예제

프로그래밍하기 가장 간단한 모드인 프레임 버퍼 모드로 비디오 모드를 설정해 보자. 일단 Engine A와 Engine B에 모두 설정 가능한 프레임 버퍼모드는 256 * 192 pixel 32768 color(15bit)이다.

그럼 설정하는 순서를 다시 생각해 보면 Display 모드를 선택하고, VRAM을 맵핑한 다음, Background 속성을 설정해 주면 된다.

아래는 간단히 프레임 버퍼 모드로 설정하는 코드이다. 비디오 모드 5를 사용하여 BG2와 BG3을 Extended Afine 모드로 설정하고 Background의 크기를 화면 전체 크기(256 * 192 pixel)보다 크게 설정하여 전체를 커버 가능하도록 설정한다. 그리고 Background 모드는 Direct Color 모드를 사용하여 프레임 버퍼모드와 비슷하게 사용하고 BG3의 시작을 Offset 0에서 시작하도록 하여 VRAM의 첫번째 시작부터 화면에 표시되도록 했다.

/**
    Main LCD 및 SUB LCD를 모두 16bit 256 * 196 로 설정한다.
        Frame Buffer와 같이 쓸 수 있도록 수정한다.
*/
void InitVideoMode()
{
    // set the mode for 2 text layers and two extended background layers
    videoSetMode( MODE_5_2D | DISPLAY_BG3_ACTIVE );
    videoSetModeSub( MODE_5_2D | DISPLAY_BG3_ACTIVE );

    // Video Memory를 설정한다. MAIN 같은 경우는 2개의 VRAM이 맵핑되어있으므로
    // 더블 버퍼의 사용도 가능하다.
    vramSetMainBanks( VRAM_A_MAIN_BG_0x06000000, VRAM_B_MAIN_BG_0x06020000,
                   VRAM_C_SUB_BG, VRAM_D_LCD);
    // Background에 대한 설정을 한다. BG_BMP_BASE를 조절하면 스크롤 및
    // 더블 버퍼를 구현할 수 있다.
    BG3_CR = BG_BMP16_256x256 | BG_BMP_BASE( 0 );// | BG_PRIORITY( 3 );
    // scale을 1, rotation을 0으로 설정하여 frame buffer와 같게 만듬
    BG3_XDX = 1 << 8;
    BG3_XDY = 0;
    BG3_YDX = 0;
    BG3_YDY = 1 << 8;
    // Translation(Reference Point X/Y-Coordinate)을 0으로 설정
    BG3_CX = 0;
    BG3_CY = 0;
    // x축 및 y축으로 100 pixel 이동
    //BG3_CX = 100 << 8;
    //BG3_CY = 100 << 8;

    SUB_BG3_CR = BG_BMP16_256x256 | BG_BMP_BASE( 0 );// | BG_PRIORITY( 3 );
    SUB_BG3_XDX = 1 << 8;
    SUB_BG3_XDY = 0;
    SUB_BG3_YDX = 0;
    SUB_BG3_YDY = 1 << 8;
    SUB_BG3_CX = 0;
    SUB_BG3_CY = 0;
// Display에서 VBlank interrupt를 발생시키도록 한다.
REG_DISPSTAT |= DISP_VBLANK_IRQ;
}

위의 각 함수 및 메크로들은 ndslib 폴더에 source 및 include 폴더에 있는 video.h/c 파일에 있다. 매크로는 첨부파일을 참고하도록 하자.

마지막에 있는 붉은 색 부분은 Display Status 레지스터에 VBLANK 인터럽트를 발생하도록 설정하는 부분이다. 이렇게 하면 주기적으로 화면을 다시 그리는 타이밍에 인터럽트가 발생하여 작업을 처리할 수가 있다.

인터럽트에 대한 자세한 내용은 04 인터럽트 제어(Interrupt Control) 문서를 참조하자.

5.1 화면 스크롤

만약 화면을 스크롤하고 싶다면 어떻게 하면 될까? BG3를 사용한다면 BG3_CY 및 CX에 값을 넣어주면 된다. BG3_CY/CX는 하위 8bit는 소수점을 나타내고 상위 7Bit는 정수부를 나타내므로 8 만큼 좌측으로 Shift 하면 된다.

5.2 더블 버퍼링

만약 더블 버퍼를 사용한다면 BG3_CX/CY를 사용해도 되지만 BG_BMP_BASE() 매크로를 이용하여서 Base Offset을 변경하는 방법도 사용할 수 있다. 256 * 192 pixel * 2Byte를 하면 한 화면에 총 데이터가 96Kbyte가 된다.

Bitmap 모드일때 Base의 값에 16Kbyte를 곱하게 되므로 BG_BMP_BASE( 6 )과 같이 사용하게 되면 프레임 간에 겹치지 않게 사용할 수 있어서 더블 버퍼링이 가능하다.

5.3 인터럽트(Interrupt)

LCD 화면을 Display 할때 한 라인 또는 전체 화면을 그렸을 때, 특정한 신호를 발생하게 할 수 있다. 한 라인을 그렸을 때 H Blank가 발생하며, 전체 화면을 다 그렸을 때가 V Blank가 발생한다. Display 인터럽트에 대한 자세한 내용은 http://nocash.emubase.de/gbatek.htm#lcdiointerruptsandstatus 에서 볼 수 있으며 NDS 인터럽트에 대한 내용은 04 인터럽트 제어(Interrupt Control)에서 찾을 수 있다.

4000004h - DISPSTAT - General LCD Status (Read/Write)
Display status and Interrupt control. The H-Blank conditions are generated once per scanline, including for the 'hidden' scanlines during V-Blank.
Bit   Expl.
  0     V-Blank flag   (Read only) (1=VBlank)
  1     H-Blank flag   (Read only) (1=HBlank)
  2     V-Counter flag (Read only) (1=Match)
  3     V-Blank IRQ Enable         (1=Enable)
  4     H-Blank IRQ Enable         (1=Enable)
  5     V-Counter IRQ Enable       (1=Enable)
  6-7   Not used
  8-15  V-Count Setting            (0-227)
The V-Count-Setting value is much the same as LYC of older gameboys, when its value is identical to the content of the VCOUNT register then the V-Counter flag is set (Bit 2), and (if enabled in Bit 5) an interrupt is requested.

4000006h - VCOUNT - Vertical Counter (Read only)
Indicates the currently drawn scanline, values in range from 160-227 indicate 'hidden' scanlines within VBlank area.
Bit   Expl.
  0-7   Current scanline (0-227)
  8-15  Not Used
Note: This is much the same than the 'LY' register of older gameboys.

6. 첨부

Part15. Tutorial3-동기화(Synchronization) 기능을 추가해 보자

Tue, 13 Sep 2011 14:14:08 +0900

Part15. Tutorial3-동기화(Synchronization) 기능을 추가해 보자

원문 : http://kkamagui.springnote.com/pages/368015

들어가기 전에...

이 글은 kkamagui에 의해 작성된 글입니다.
마음껏 인용하시거나 사용하셔도 됩니다. 단 출처(http://kkamagui.tistory.com, http://kkamagui.springnote.com)는 밝혀 주십시오.
기타 사항은 mint64os at gmail.com 이나 http://kkamagui.tistory.com으로 보내주시면 반영하겠습니다.
상세한 내용은 책 "64비트 멀티코어 OS 원리와 구조"를 참고하기 바랍니다.

0.시작하면서...

앞서 멀티 태스킹 기능을 추가하면서 동기화가 얼마나 중요한지 느꼈을 것이다. 잘 모르겠다면 커널 크래쉬 화면을 한번 더 보고 오자. 단순히 3개의 태스크만 실행되는 스케줄러를 구현하는데도 동기화 문제가 발생하니, 윈도우와 같이 수백개의 태스크가 동작하는 OS에서 동기화는 PC의 CPU 만큼이나 중요한 문제다.

효율적인 동기화를 위해 몇가지 동기화 오브젝트를 설계하고 구현해보자.

1.동기화 객체(Synchronization Object)

이번에 구현해볼 동기화 객체는 세머포어(Semaphore)와 뮤텍스(Mutex)이다. 사실 뮤텍스는 카운트가 1인 바이너리 세머포어와 기능이 비슷하기 때문에 세머포어를 구현하고 그것을 이용해서 뮤텍스를 구현하도록 하자. 뮤텍스는 소유의 개념이 포함되어있어 바이너리 세마포어와는 차이가 있지만 세부적인 내용은 넘어가도록 하자(궁금한 사람은 구글링을 @0@)/~)

윈도우 프로그래밍을 어느정도 해본 사람, 혹은 스레드 프로그래밍을 어느정도 해본 사람이라면 세머포어와 뮤텍스에 대해서 이미 알고 있을 것이다.

그래도 혹여나 모르는 사람들이 있을까봐 간단히 용도를 설명하겠다.

여러 태스크에서 하나의 공유된 자원(글로벌 변수 or IO 장치 등등)에 접근하게되면 서로 경쟁을 하게 된다. 이 공유된 자원을 순차적으로 사용하고 반납하게 되면 자원에 동시에 접근했을 때 발생하는 문제를 해결할 수 있고, 태스크 간의 "순차적인 사용"을 컨트롤 하기위해 세머포어나 뮤택스를 사용한다.

앞서 Tutorial에서 멀티태스크의 기능을 구현할 때 스케줄러의 예를 보면 잘 알 수 있다. 글로벌 구조체인 gs_stScheduler가 태스크 간에 공유된 자원이었고 무차별하게 접근할때 커널 크래쉬가 발생했다. 이것을 kLock()과 kUnlock() 메소드를 사용하여 태스크 간의 접근을 컨트롤하였고 스케줄러가 정상적으로 동작할 수 있었다. 잘 기억이 안나는 사람은 Part14. Tutorial2-멀티 태스킹(Multi Tasking) 기능을 추가해 보자를 다시 보도록 하자.

2.세머포어(Semaphore) 설계

세머포어는 크게 카운팅 세머포어(Counting Semaphore)와 바이너리 세머포어(Binary Semaphore)로 나뉘어진다. 두 세머포어의 차이점은 자원에 진입할 수 있는 태스크의 수가 단 한개만 가능한가, 아니면 n개가 가능한가 차이밖에 없다. 세머포어의 사용법은 동기화가 필요한 영역에 진입할 때 On()을 하고 작업을 완료하면 Off()를 호출하는 방식으로 사용하며 On과 Off 사이의 코드는 세머포어의 종류에따라 하나의 태스크만 실행가능하거나 n개의 태스크만 실행할 수 있다.

세머포어를 깃발과 방으로을 생각하면 이해하기가 좋다. 어떤 방에 들어가는데, 방에 들어가면 입구에 깃발을 하나 올리고 방에서 나오면 깃발을 하나 내린다. 만약 내가 들어갈 차례인데 깃발이 전부 올려져 있으면 누군가 나와서 깃발을 내릴 때까지 기다렸다가 들어가는 방식이다.

카운팅 세머포어를 구현하기 위해서는 진입 가능한 태스크의 최대 개수, 현재 진입한 태스크의 수를 포함하는 세머포어 자료구조가 필요하다. 이를 아래와 같이 선언하자.

// Semaphore 구조체
typedef struct semaphoreStruct
{
    BOOL bLock;
    int iMaxTask;
    int iCurTask;
} SEMAPHORE, * PSEMAPHORE;

중요하게 볼 부분은 bLock 부분인데, 세머포어의 변수들 또한 공유되는 자원이므로 이 자원을 수정할 수 있는가 판단하는 플래그가 필요하다. 이 플래그가 없으면 어떻게 될까? 세머포어의 변수를 설정하고 비교하는 부분 역시 여러 태스크가 접근할 것이므로 역시 엉망이 될 것이다(커널 크래쉬를 잊지말기를 바란다).

3.구현

3.1 세머포어(Semaphore) 구현

위에서 세머포어에 대해 간략히 설계했으므로 이제 코드를 작성해 보자. iMaxTask 변수는 최대로 진입 가능한 태스크의 수로 사용하고 iCurTask는 현재까지 진입한 태스크의 수로 사용한다면, 초기화/On/Off 코드는 아래와 같이 쓸 수 있다.

/**
    Semaphore를 초기화 한다.
*/
void InitSemaphore( SEMAPHORE* pstSema, int iMaxTask )
{
    kMemSet( pstSema, 0, sizeof( SEMAPHORE ) );
    pstSema->iMaxTask = iMaxTask;
}
/**
    Semaphore를 점유한다.
*/
BOOL OnSemaphore( SEMAPHORE* pstSema )
{
    // 세머포어 변수에 접근하기위해 접근이 가능한지를 확인하고 접근 가능하면
    // 접근 금지를 설정한 후 변수를 본다.
    while( 1 )
    {
        if( kLock( &( pstSema->bLock ) ) == FALSE )
        {
            SwitchTask();
            continue;
        }
        if( pstSema->iCurTask + 1 <= pstSema->iMaxTask )
        {
            break;
        }
        else
        {
            kUnlock( &( pstSema->bLock ) );
            SwitchTask();
        }
    }
pstSema->iCurTask++;
// 세버포어 변수에 대한 접근 금지를 해제한다.
kUnlock( &( pstSema->bLock ) );
return TRUE;
}
/**
    Semaphore를 해제한다.
*/
BOOL OffSemaphore( SEMAPHORE* pstSema )
{
    // 세머포어 변수에 접근하기위해 접근이 가능한지를 확인하고 접근 가능하면
    // 접근 금지를 설정한 후 변수를 본다.
    while( 1 )
    {
        if( kLock( &( pstSema->bLock ) ) == FALSE )
        {
            SwitchTask();
            continue;
        }
        if( pstSema->iCurTask > 0 )
        {
            break;
        }
        else
        {
            kUnlock( &( pstSema->bLock ) );
            SwitchTask();
        }
    }
pstSema->iCurTask--;
// 세버포어 변수에 대한 접근 금지를 해제한다.
kUnlock( &( pstSema->bLock ) );
return TRUE;
}

초기화하는 함수는 쉽게 이해가될테니 넘어가고 OnSemaphore()와 OffSemaphore() 함수를 보자. 낯이 익은 함수가 보이지 않는가? kLock()과 kUnlock() 함수가 여러번 나오는데, 이 함수는 Atomic하게 동작하는 함수로 아래와 같은 역할을 한다.

BOOL kLock( BYTE* pbFlag ) : Atomic Operation으로 pbFlag의 값이 0이면 1로 설정하고 1을 리턴하고, 1이면 0을 리턴
BOOL kUnlock( BYTE* pbFlag ) : Atomic Operation으로 pbFlag의 값이 1이면 0으로 설정하고 1을 리턴하고, 0이면 0을 리턴

위의 함수 설명과 세머포어 코드를 같이 보면 전체적인 흐름을 이해하는데 문제가 없을 것이다. 위의 코드를 순서대로 나열하면 아래와 같다.

kLock()을 호출하여 내가 세머포어 변수를 수정할 수 있는지 확인한다.
TRUE가 리턴되면 다른 태스크가 세머포어 변수를 수정하고 있지 않으므로 세머포어 값을 변경한다.
변경이 끝나면 kUnlock()을 호출하여 세머포어 변수를 수정할 수 있음을 설정한다.
FALSE가 리턴되면 다른 태스크가 세머포어 변수를 수정하고 있으므로 TRUE가 리턴될 때까지 대기한다.

여기서 잠깐... 세머포어를 구현하는데 꼭 필요한 것이 Atomic Operation이라는 것을 알았다. 그러면 어떻게 Atomic Operation을 구현할 수 있을까? Atomic함을 보장하기위해서 필요한 것은 무엇일까?

그것은 명령을 수행할 때 도중에 인터럽트되지 않고 처리를 끝내는 것이다. 아래와 같이 인터럽터를 Disable 함으로써 간단히 Atomic Operation을 구현할 수 있다(Single CPU라고 가정한다).

; BYTE *pbFlag : 옛날버전
;     인터럽터를 Disable 시키고, 플래그를 검사하여
;  플래그의 값이 0 이면 1로 증가시키고 1을 리턴하고,
;  플래그의 값이 1 이면 0을 리턴한다.
_kLockOld:
  push    ebp
  mov     ebp, esp
  push    ebx
  pushfd
  ; 플래그의 포인터를 얻는다.
  mov     ebx, dword [ss:ebp + 8]
  ; 인터럽터 Disable
  cli
  mov  al, byte [ds:ebx]
  cmp  al, 0
  ; 일단 FALSE를 셋팅해 놓고
  mov  eax, 0x00000000
  jne  kLockExit
mov byte [ds:ebx], 0x01
mov eax, 0x01
kLockExit:
  popfd
  pop     ebx
  pop     ebp
  retn
; BYTE *pbFlag : 옛날 버전
;     인터럽터를 Disable 시키고 플래그를 검사하여
;  플래그의 값이 1 이면 0로 감소시키고 1을 리턴하고
;  플래그의 값이 0 이면 0을 리턴한다.
_kUnlockOld:
  push    ebp
  mov     ebp, esp
  push    ebx
  pushfd
  ; 플래그의 포인터를 얻는다.
  mov      ebx, dword [ss:ebp + 8]
  ; 인터럽터 Disable
  cli
  mov  al, byte [ds:ebx]
  cmp  al, 1
  ; 일단 FALSE를 셋팅해 놓고
  xor      eax, eax
  jne  kUnLockExit
mov byte [ds:ebx], 0
mov eax, 0x01
kUnLockExit:
  popfd
  pop  ebx
  pop      ebp
  retn

주석에 표시된대로 더 이상 사용되지 않는다(프레임워크 처음 릴리즈시 버전). 위에서 보듯 인터럽트를 불가로 설정하고 다시 인터럽터 관련 플래그(EFLAG) 레지스터를 복원하는 방식으로 Atomic을 보장했다. 하지만 이 방법의 문제점은 너무 자주 인터럽트를 불가로 설정하기 때문에 인터럽트 처리가 지연될 수 있다.

Intel Architecture Manual의 Volume 2 Instruction Set을 보면 Atomic한 처리를 위한 명령어들이 나와있다. lock 명령과 xchg, cmpxchg 명령이 그것이다.

cmpxchg mem, reg 명령어의 역할은 아래와 같다(자세한 설명은 Intel Architecture Volume 2, Instruction Set 문서를 참고하도록 하자).

mem과 al 레지스터의 값이 같음 : reg의 값을 mem에 복사를 하고 ZF 플래그를 1로 설정
mem과 al 레지스터의 값이 다름 : reg에 mem의 값을 복사하고 ZF 플래그를 0로 설정

아래는 lock, cmpchg를 이용해서 수정한 코드다.

; BYTE *pbFlag :
;  플래그의 값이 0 이면 1로 증가시키고 1을 리턴하고,
;  플래그의 값이 1 이면 0을 리턴한다.
_kLock:
  push    ebp
  mov     ebp, esp
  push ebx
mov al, 0
mov ah, 1
  mov  ebx, dword [ss:ebp + 8 ]
  ; 메모리의 값이 al과 같으면 ah를 메모리에 넣고 zf를 1로 셋팅
  lock cmpxchg byte [ds:ebx], ah
  je  LOCKSUCCESS
  mov  eax, 0
  jmp  LOCKEND
LOCKSUCCESS:
  mov  eax, 1
  jmp  LOCKEND
LOCKEND:
  pop ebx
  pop ebp
  retn
; BYTE *pbFlag : 옛날 버전
;     인터럽터를 Disable 시키고 플래그를 검사하여
;  플래그의 값이 1 이면 0로 감소시키고 1을 리턴하고
;  플래그의 값이 0 이면 0을 리턴한다.
_kUnlock:
  push ebp
  mov ebp, esp
  push ebx
mov al, 1
mov ah, 0
  mov  ebx, dword [ss:ebp + 8 ]
  ; 메모리의 값이 al과 같으면 ah를 메모리에 넣고 zf를 1로 셋팅
  lock cmpxchg byte [ds:ebx], ah
  je  UNLOCKSUCCESS
  mov  eax, 0
  jmp  UNLOCKEND
UNLOCKSUCCESS:
  mov  eax, 1
  jmp  UNLOCKEND
UNLOCKEND:
  pop ebx
  pop ebp
  retn

3.2 KShell.c/h 수정

자 그럼 이제 세머포어를 사용해보자. kShell.c 파일을 아래와 같이 수정한다.

SEMAPHORE gs_stSema; <= 세머포어 구조체 정의
/**
    KShell 의 Main
*/
void Shell()
{
    InitScheduler();
    InitSemaphore( &gs_stSema, 1 );   <= 세머포어 초기화, 하나의 태스크만 실행가능하도록 설정
    // 새로운 태스크 등록
    AddTask( EdgeDraw );
    EnableScheduler( TRUE );

    ShellLoop();
while( 1 );
}
/**
글로벌 변수에서 값을 읽어서 문자를 찍어주는 함수
*/
int gs_iX = 0;
int gs_iY = 0;
void Print( BYTE bCh )
{
int i;
    printchxy( gs_iX, gs_iY, bCh );

    // 약간의 Delay를 위해 사용
    kIdle();
printchxy( gs_iX, gs_iY, ' ' );
}
/**
    테두리를 그려주는 태스크
*/
void EdgeDraw( void )
{
    int i;
    int j;
    BYTE bCh;
    int k;
    char vcBuffer[ 8 ];
    int iTID;
    i = 0;
    j = 0;
    bCh = 0;
    iTID = GetCurrentTID();

    kDToA( vcBuffer, iTID );
    for( k = 0 ; k < 50000 ; k++ )
    {
        printxy( 0, 23 - iTID, "=EdgeDraw Task Work=" );
        printxyn( 20, 23 - iTID, vcBuffer, 8 );
        // 콘솔 테두리를 돌면서 .을 찍는다.
        for( i = 30 ; i < 79 ; i++ )
        {
            // Semaphore 대기
            OnSemaphore( &gs_stSema );
            gs_iX = i;
            gs_iY = 23 - iTID;
            Print( bCh );
            bCh++;
            OffSemaphore( &gs_stSema );
            SwitchTask();
        }
    }
}

위에 파란색 부분을 보면 Print() 함수가 새로 정의되었는데, 글로벌 변수 gs_iX, gs_iY에서 값을 읽어 화면에 한 문자를 출력했다가 일정시간 뒤에 다시 공백으로 지우는 역할을 하는 함수이다. EdgeDraw()에서 수정된 부분은 OnSemaphore()/OffSemaphore() 함수를 사용하고 그 안에 글로벌 변수 X,Y에 값을 설정한 후 Print() 함수를 호출한 부분이다.

각 태스크가 공유 자원인 gs_iX 및 gs_iY에 접근하여 값을 설정하고 Print() 함수를 호출하여 다시 공유자원의 값을 사용하는 구조이다. 이것을 빌드하여 이미지를 만든 다음 Virtual Box에서 실행한 상태에서 starttask 명령을 3번정도 입력하여 화면을 지켜보자.

<Start Task With Semaphore>

위와 같은 화면이 표시될 것이다. starttask를 3번 사용하여 총 4개의 task를 생성하였고 각각의 태스크는 문자를 보여주고 지워졌다가 다시 다른 문자를 보여주는 아주 깔끔한 화면을 보여준다. 세머포어가 동시에 수행될 수 있는 태스크의 수를 1개로 하여 생성되었기때문에 글로벌 변수에 값을 설정하고 화면에 값을 출력하기까지 다른 태스크가 끼어들지 못하여 이러한 결과가 나온 것이다.

하지만 OnSemaphore()와 OffSemaphore() 함수를 주석처리하고 다시 실행해보자.

<Start Task Without Semaphore>

절대 일부러 합성한 화면이 아님을 미리 알려둔다. 글로벌 변수에 값을 설정하고 Print() 함수를 호출하는 과정에서 중간 중간에 태스크 스위칭이 되어 다른 태스크가 끼어든 결과이다. 정상적으로 문자가 출력되지 않고 또한 제대로 지워지지도 않는다.

예제로 들기에는 약간 부족한 면이 있지만 이것으로 세머포어의 역할이나 구현에 대해서 어느정도 감을 잡았으리라 생각된다.

4.뮤텍스(Mutex)

뮤텍스는 바이너리 세머포어와 비슷하다. 다만 다른점은 뮤텍스는 소유의 개념이 있어서 On 시에 태스크 ID를 저장해 두고 Off 시에 태스크 ID를 비교해서 On을 수행한 태스크만 처리가 가능하다.

그럼 어떤 방식으로 뮤텍스를 구현할 수 있을까? 아래와 같이 구현하면 된다.

OnMutex() : 위에서 보았던 세머포어 구조체에 TID 필드를 추가하고 OnMutex() 함수를 만든뒤 바이너리 세머포어와 동일하게 구현한다. 그리고 마지막에 TID를 보관한다.
OffMutex() : 가장 먼저 TID를 비교하여 OnMutex()를 실행한 태스크인지 비교한뒤 바이너리 세머포어의 Off 함수와 동일하게 구현한다.

크게 어렵지 않은 부분이므로 각자 구현해 보도록 하자.

5.마치며...

이제 동기화 객체도 생성되었으니 멀티 태스킹 프로그래밍을 마음껏 할 수 있다(정말?? ㅡ,.ㅡ;;;). 부담없이 태스크를 만들고 돌려보자. @0@)/~

6.첨부

6.1 프레임워크 1.0.3 이전

Asm.asm : 수정된 kLock(), kUnlock() 함수 포함
Custom.zip : kShell, Syncrhonize 파일 포함
makefile : Makefile

6.2 프레임워크 1.0.3 이후

Custom_1_0_3.zip

Part16. Tutorial4-메모리 동적할당(malloc, free) 기능을 추가해 보자

Tue, 13 Sep 2011 14:13:57 +0900

Part16. Tutorial4-메모리 동적할당(malloc, free) 기능을 추가해 보자

원문 : http://kkamagui.springnote.com/pages/391653

들어가기 전에...

이 글은 kkamagui에 의해 작성된 글입니다.
마음껏 인용하시거나 사용하셔도 됩니다. 단 출처(http://kkamagui.tistory.com, http://kkamagui.springnote.com)는 밝혀 주십시오.
기타 사항은 mint64os at gmail.com 이나 http://kkamagui.tistory.com으로 보내주시면 반영하겠습니다.
상세한 내용은 책 "64비트 멀티코어 OS 원리와 구조"를 참고하기 바랍니다.

0.시작하면서...

이번에는 프로그래밍에서 빠져서는 안될 부분, 메모리 동적 할당(malloc, free)을 한번 구현해 보자. 이미 동기화 오브젝트에 대한 구현이 끝났기 때문에 멀티 태스킹 환경에서도 잘 동작하는 동적 할당 모듈을 작성할 수 있다. 오늘은 간단히 동적할당에 대해서만 구현하고 동기화는 다음에 따로 구현해보자.

1.메모리 공간 할당

동적할당을 구현하기 위해서는 동적 할당을 위한 공간을 마련해야 하는데, 이전에 봤던 OS 프레임워크의 메모리 레이아웃을 다시 보자(너무 많이봐서 외우는 사람도 있을 것이다 ㅎㅎ).

<프레임워크 메모리 레이아웃>

커널 스택의 끝이 0x400000에 위치하므로 4Mbyte 이상의 영역은 비어있다. 이 공간을 동적 할당의 공간으로 사용하자. 그럼 시작 주소는 4M로 정해졌고 이제 영역의 끝을 정해야하는데, 끝 주소를 8M 정도로 하면 괜찮을 듯 하다. 작은 커널이기 때문에 메모리 사용이 그렇게 많지 않을 것이고, 혹여 메모리를 많이 쓴다면 끝 주소를 더 늘리면 되므로 걱정하지 말자. 단 Virtual Box의 메모리도 거기에 맞추어 변경해줘야 하는데 지금은 8Mbyte 이상으로 설정하면 충분하다.

2.메모리 할당 정책

자 이제는 어떤 알고리즘으로 메모리를 할당할까?

생각할 수 있는 제일 간단한 방법은 무조건 고정크기의 블럭을 할당하는 것이다. 즉 프로그램은 크기를 요청할 수 없고, 메모리 할당을 요청하면 특정 크기의 블럭을 할당 받기 때문에 "알아서" 사용해야 한다. 블럭의 크기를 관리할 필요가 전혀 없기때문에 아주 간단하다. 천지 쓸모 없을 것 같은 방법이지만... 실제로 이와 비슷하게 할당 받아서 "잘" 동작하는 어플리케이션이 있다.

대용량 데이터를 처리하는 데이터베이스와 같은 프로그램의 경우, 운영체제로부터 큰 블럭을 할당받고 나름 최적화된 알고리즘으로 나누어 사용한다. 어플리케이션만 똑똑하다면 얼마든지 가능하다는 이야기다. 단점은 어플리케이션 개발자를 혹사 시킬 수도 있다는... ㅡ_ㅡ;;;( 요즘 메모리 관리를 못하는 어설픈 개발자가 어디 한둘이어야... ㅡ_ㅡ;;;;; )

두번째 방법은 블럭 영역을 검색해서 할당하는 방법이다. 제일 딱맞는 크기를 할당해 준다던지, 아니면 첫번째 만난 가능한 공간을 할당해 준다던지 하는 알고리즘으로 할당 가능한 영역을 찾아서 할당해 주는데, Best fit이니 Worst fit 이니 하는 방법들로 널리 알려져있다. 이 방법을 사용하면 가변 크기의 블럭들을 할당하고 해제할때 발생하는 단편화(Fragmentation)을 피하기가 어렵다.

세번째 방법은 좀 더 스마트(Smart)한 방법인데, 익히 버디 블럭(Buddy Block) 알고리즘으로 알려진 방법이다(Linux에서 채택하고 있다). 이름 그대로 친한 친구끼리 어떻게 저떻게 처리하는 알고리즘인데, 아래에서 자세히 알아보자.

3.버디 블럭 알고리즘(Buddy Block Algorithm)

버디 블럭 알고리즘은 크게 아래와 같은 단계로 수행된다(예를 든것이다. 숫자에 너무 연연하지 말자).

초기화 (Initialize)
- 메모리 영역을 적당한 크기로 나눈다(4Kbyte라고 가정하자) . 나누고 나니 n개 생겼다.
- 연속된 4Kbyte 블럭들 2개를 합하면 하나의 8Kbyte 블럭을 만들 수 있다. 이것을 전체 영역에 반복하니 (n/2)개가 생겼다.
- 연속된 8kbyte의 블럭들을 2개 합하면 하나의 16Kbyte의 블럭을 만들 수 있다. 이것을 전체 영역에 반복하니 (n/4)개가 생겼다.
- 계속 반복하다 보니 1개의 XKbyte의 블럭이 생겼다.

메모리 할당 (malloc)
- 4Kbyte 크기의 메모리 할당 요청이 들어왔다.
- 4Kbyte 크기영역 중에 빈 영역이 있는지 확인한다.
- 빈 영역이 있으면 할당해준다.
- 만약 없으면 위의 8Kbyte 블럭을 찾는다.
- 8Kbyte 중에 빈 블럭이 있으면 그 블럭을 4Kbyte의 2개로 나누고 그중 하나를 프로그램에 넘겨주고 나머지 하나는 4Kbyte 블럭에 달아둔다.
- 만약 8Kbyte 영역에 없으면 16Kbyte를 보고 하나 할당해서 4Kbyte를 프로그램에 넘겨주고 나머지 4Kbyte와 8Kbyte를 블럭에 달아둔다.
- 할당 가능할때까지 이를 반복해서 마지막 1개 남은 XKbyte 블럭도 할당 불가능하면 실패한다.

메모리 반납 (free)
- 4Kbyte 크기의 메모리 반납 요청이 들어왔다.
- 4Kbyte 해당 영역에 블럭을 반납하고 앞뒤 블럭의 상태가 Free인가 확인한다.
- 만약 Free라면 4Kbyte + 4Kbyte 블럭을 하나로 합쳐서 상위 8Kbyte 블럭으로 반납한다.
- 8Kbyte 블럭에 반납한 다음 앞뒤 블럭의 상태가 Free인가 확인한다.
- 만약 Free라면 8Kbyte + 8Kbyte 블럭을 하나로 합쳐서 상위 16Kbyte 블럭으로 반납한다.
- 위 과정을 합치는 것이 가능할 때까지 반복한다.

위와 같은 알고리즘을 계속하여 반복하므로 가변 길이의 블럭이 할당과 해제를 반복했을 때 발생하는 단편화(Fragmentation)현상을 어느정도 방지할 수 있다. 실제로 이 방법이 Linux 커널에서 2.4 버전 이전 대 까지 사용된 방법이다. 그 뒤로는 슬랩(Slab) 방식과 혼합해서 사용한다던데... 분석을 열심히하지 않아서 잘... ㅎㅎ...(좋은 자료 있으면 방명록이나 덧글로.. ㅎㅎ)

말로 설명하기 복잡한데, 위의 글을 그림으로보면 이해하기 쉽다. 시스템 전체 메모리가 12Kbyte 정도이고 최초/최대 할당 크기가 1Kbye에서 4Kbyte까지라면 초기 메모리 블럭은 아래와 같은 구성으로 되어있을 것이다(파란색으로 체워진 블럭은 Free 상태의 블럭이다).

<버디 블럭 초기화>

이 상태에서 1KB 블럭을 2개 할당받으면 1Kbyte에 블럭이 없고 2Kbyte에도 블럭이 없기때문에 4Kbyte짜리 블럭 하나를 쪼개 2Kbyte 2개로 나누게 된다. 그 중에 한 블럭을 다시 1Kbyte 2개로 나누게 되고 각각을 할당해 주게 된다. 이때 할당받은 각각의 블럭을 A와 B라고 하자. 이것을 그림으로 표현하면 아래와 같다(붉은색 블럭은 Alloc 상태의 블럭이다).

<1Kbyte 크기의 블럭 2개 할당>

이제 전체 시스템에는 4Kbyte 2개와 2Kbyte 1개가 남은 상태이다. 다시 1Kbyte 하나 할당 받으면 1Kbyte 블럭에는 여유분이 없으므로 2Kbyte 블럭을 1Kbyte 2개의 블럭으로 나누고 그중 하나를 할당하게 된다. 이때 할당받은 블럭을 C라고 하자. 이것을 그림으로 표현하면 아래와 같다.

<1Kbyte 블럭 1개 추가 할당>

어느덧 시간이 흘러 할당한 블럭의 사용이 끝나서 블럭 C를 반납했다. C블럭을 반납하고 나면 바로 옆의 블럭이 Free 상태의 블럭이므로 이 두 블럭을 합하여 상위 2Kbyte 블럭을 만들 수 있다. 이것을 그림으로 표현하면 아래와 같다.

<1Kbyte 블럭 1개 반납>

이제 시스템에는 2Kbyte 1개의 블럭과 4Kbyte 2개의 블럭이 Free 상태로 존재한다. 때마침 할당되었던 A와 B 블럭이 반납되었다. 그러면 각각 반납한 후 서로의 블럭을 합하면 하나의 2Kbyte 블럭을 생성할 수 있으므로 합쳐 2Kbyte 블럭 하나를 구성한다. 이때 다시 우측을 보면 2Kbyte 블럭이 인접하여 존재하므로 다시 이 둘을 합하여 상위의 4Kbyte 블럭을 만들 수 있다. 이 수행이 끝나면 다시 초기상태와 같은 4Kbyte 블럭 3개가 존재하게 된다.

<1Kbyte 블럭 반납>

<1Kbyte 블럭 반납-블럭 통합>

<블럭 통합 완료>

모든 작업이 끝나고 블럭이 초기상태로 복원되었다. 이것으로 메모리 할당과 해제가 끝났다.

4.구현

4.1 00Kernel/Custom/Memory.h/c

버디 블럭 알고리즘은 할당 가능한 메모리의 최소 크기와 최대 크기를 정의해야한다. 우리는 메모리 할당의 최대크기를 4Mbyte(빈 영역의 최대공간)로 하고 최소 크기는 512Byte로 하자. 그럼 최대 크기와 최소 크기 사이가 총 13단계로 나누어지게 된다. 그럼 메모리 공간을 나타내기위한 14개의 영역관리가 필요하다는 결론이 나오는데, 비트 마스트(Bitmask)를 이용해서 관리하자.

버디 블럭을 구현하는 방법은 몇가지가 있는데, 한가지는 링크드 리스트(Linked List)를 이용하는 방법이고, 그 다음 방법은 비트 마스크(Bitmask)를 이용하는 방법이다. 리스트를 사용하는 것이 좀더 쉬울 수 있으나 효율면에서는 비트마스크를 사용하는 것이 좋다. 프레임워크 소스 코드는 비트마스크를 사용하여 구현되었다(리스트를 사용하는 방법은 옛날에 한번 해봤다는 지극히 개인적인 이유.... ㅡ_ㅡ;;;).

비트 마스크를 이용하기로 했으니, 비트마스크의 총 크기를 알아야 한다.

4Mbyte 영역을 512byte 블럭으로 나누면 총 8192개가 나온다. 한 바이트가 8bit이므로 8로 나누면 1024Byte 즉 1Kbyte가 필요하다. 그렇다면 1024byte 블럭은 얼마 크기의 비트마스크가 필요할까? 블럭 크기가 512Byte의 2배이므로 512Byte가 필요하다. 2048byte(2Kbyte)의 블럭은? 256Byte 크기의 비트마스크가 필요하다. 이를 반복하면 각 메모리 블럭당 필요한 바이트 수를 구할 수 있다.

위의 계산방법을 통해 총 필요한 단계와 각 단계에 필요한 비트 마스크 배열의 크기를 계산하고, 블럭 해제시에 사용할 할당된 크기값을 저장하기위한 배열을 추가하여 동적 할당 구조체를 만들자.

// 동적 할당을 정보를 저장할 구조체
// 최대 비트마스크의 크기인 MEMORY_MAX_BITMASKCOUNT개의 크기로
// MEMORY_MAX_BITMASKLISTCOUNT개 만든다.
// 메모리 용량을 줄이고 싶으면 아래를 튜닝하면 된다.
typedef struct memoryStruct
{
DWORD vdwSizeArray[ MEMORY_ALLOC_MAX_SIZE / MEMORY_ALLOC_MIN_SIZE ];
BYTE vvbBitMask[ MEMORY_MAX_BITMASKLISTCOUNT ][ MEMORY_MAX_BITMASKCOUNT ];
} MEMORY, * PMEMORY;

구조체를 만든 다음 함수가 몇가지 필요하다.

버디 블럭 알고리즘이 정해진 블럭의 크기만큼 Align하여 할당하므로 메모리 할당 요청시에 적당한 크기의 블럭을 찾는 함수
비트 마스크를 조작하는 함수
버디 블럭 알고리즘으로 블럭을 할당하고 해제하는 함수

알고리즘이 나름 복잡한 관계로 함수 원형만 추출했다. 구현에 대한 실제 코드는 첨부에서 받을 수 있다.

void InitMemory( void );
void* AllocMemory( int iSize );
BOOL FreeMemory( void* pvAddress );
int AllocBuddy( int iAlignSize );
BOOL FreeBuddy( int iListIndex, int iMaskOffset );
int GetAlignSize( int iSize );
int GetListIndexOfMatchSize( int iSize );
BOOL IsValidListIndex( int iIndex );
BYTE* GetMaskArray( int iListIndex );
int FindFreeOffsetInMask( int iListIndex );
BOOL SetFlagInMask( int iListIndex, int iOffset, BYTE bFlag );
BYTE GetFlagInMask( int iListIndex, int iOffset, BYTE* bFlag );

4.2 00Kernel/Custom/KShell.h/c

이제 실제로 테스트를 해볼 차례다. KShell.c 파일을 열어서 Shell() 함수에 Memory 초기화 함수를 추가한다.

/**
    KShell 의 Main
*/
void Shell()
{
    InitScheduler();
    InitMemory();
    InitSemaphore( &gs_stSema, 1 );
    // 새로운 태스크 등록
    AddTask( EdgeDraw );
    EnableScheduler( TRUE );

    ShellLoop();
while( 1 );
}

그리고 테스트를 위해 ProcessCommand() 함수에 malloc 명령과 free 명령을 추가한다. malloc 명령은 malloc 0x20 과 같이 사용되며 특정 크기의 블럭을 할당 받을 때 사용한다. free 명령은 malloc 명령으로 할당받은 메모리를 그대로 해제하는 역할을 한다(기능을 추가할수록 코드가 점점 길어지는.. ㅡ_ㅡ;;;). 그리고 마지막으로 동적할당 비트 마스크에 대한 정보를 표시하는 DumpMemory() 함수를 추가한다.

/**
    엔터가 쳐졌으면 버퍼의 내용으로 명령어를 처리한다.
*/
void ProcessCommand( int* piX, int* piY, char* vcCommandBuffer,
                     int* piBufferIndex)
{
    char vcDwordBuffer[ 8 ];
    static DWORD vdwValue[ 10 ];
    static int iCount = 0;
...... 생략 ......
// 메모리를 할당받는다. malloc 00000000의 형태여야 한다.
    else if( ( *piBufferIndex > 7 ) &&
             ( kMemCmp( vcCommandBuffer, "malloc", 6 ) == 0 ) )
    {
        // 라인을 변경한다.
        NewLine( piX, piY );
        vcCommandBuffer[ *piBufferIndex ] = '\0';

        // 할당할 크기 16진수
        vdwValue[ iCount ] = kAToD( vcCommandBuffer + 7 );
        kDToA( vcDwordBuffer, vdwValue[ iCount ] );
        printxy( 0, *piY, "size" );
        printxyn( 10, *piY, vcDwordBuffer, 8 );
        // 할당된 주소
        vdwValue[ iCount ] = ( DWORD ) AllocMemory( vdwValue[ iCount ] );
        kDToA( vcDwordBuffer, vdwValue[ iCount ] );
        printxy( 20, *piY, "Address" );
        printxyn( 30, *piY, vcDwordBuffer, 8 );
        iCount++;
    }
    // 메모리를 해제한다.
    else if( ( *piBufferIndex == 4 ) &&
             ( kMemCmp( vcCommandBuffer, "free", 4 ) == 0 ) )
    {
        // 라인을 변경한다.
        NewLine( piX, piY );
        if( iCount > 0 )
        {
            iCount--;
        }
        kDToA( vcDwordBuffer, vdwValue[ iCount ] );
        printxy( 0, *piY, "Address" );
        printxyn( 15, *piY, vcDwordBuffer, 8 );
        FreeMemory( ( void* ) vdwValue[ iCount ] );
    }
    // Bitmask를 덤프한다.
    else if( ( *piBufferIndex == 7 ) &&
             ( kMemCmp( vcCommandBuffer, "dumpmem", 7 ) == 0 ) )
    {
        DumpMemory( piX, piY );
    }
}
...... 생략 ......
/**
    Memory의 상태를 Dump해서 표시한다.
*/
void DumpMemory( int* piX, int* piY )
{
    int i;
    int j;
    BYTE* pbMask;
    char vcDwordBuffer[ 8 ];
    int iFindCount;
    // 블럭중에 Free 한 것을 Dump 한다.
    for( j = 0 ; j < MEMORY_MAX_BITMASKLISTCOUNT ; j++ )
    {
        NewLine( piX, piY );
        kDToA( vcDwordBuffer, MEMORY_ALLOC_MIN_SIZE << j );
        pbMask = gs_stMemory.vvbBitMask[ j ];
        printxyn( 0, *piY, vcDwordBuffer, 8 );
        iFindCount = 0;
        for( i = 0 ; i < MEMORY_MAX_BITMASKCOUNT * 8 ; i++ )
        {
            if( pbMask[ i / 8 ] & ( 0x01 << ( i % 8 ) ) )
            {
                kDToA( vcDwordBuffer, i );
                printxyn( 10 + iFindCount * 10, *piY, vcDwordBuffer, 8 );
                kGetCh();
                NewLine( piX, piY );
            }
        }
    }
}

4.3 00Kernel/makefile 수정

4.3.1 프레임워크 1.0.3 이전 버전

makefile은 깔끔히 정리된 버전을 기준으로 설명한다. 새로운 버전을 받지 않았으면 21 OS 프레임워크 소스 릴리즈에 가면 새로운 makefile을 받을 수 있다.

새로운 makefile에 OBJ 부분을 아래와 같이 수정한다.

#Object 파일 이름 다 적기
#아래의 순서대로 링크된다. 새로운 파일이 생기면 뒤에 다 추가하자
OBJ = Asm.o Kernel.o Isr.o Descriptor.o Interrupt.o Keyboard.o StdLib.o Task.o \
FrameWork.o KShell.o Scheduler.o Synchronize.o Memory.o

4.3.2 프레임워크 1.0.3 이후 버전

프레임워크 1.0.3 버전 이후는 makefile에 다 통합되어있다. Custom 폴더에 Memory.h/c 파일을 넣고 make를 입력하는 것으로 끝이다.

5.Build 및 실행

위의 모든 과정이 끝난 후 makekernel.bat 와 makeimg.bat 또는 make를 실행하면 커널이 build되고 Virtual Box로 결과를 확인할 수 있다. 아래는 실행 후 dumpmem 명령을 통해 비트 마스크의 내용을 확인한 화면이다. 맨 마지막에 0x400000 크기의 블럭이 0x00000000 인덱스에 존재한다. 이것으로 보아 4Mbyte 크기의 블럭이 정상적으로 할당되어 있음을 알 수 있다.

<초기의 메모리 비트마스크>

아래는 0x20 크기의 메모리를 할당 받은 후에 다시 메모리 상태를 본 것이다(다 표시되지는 않았지만 0x200 크기의 블럭부터 상위 0x200000 크기의 블럭까지 모두 하나씩 할당되었음을 알 수 있다).

<0x20 크기의 메모리블럭 할당 후>

하나를 할당받은 후에 다시 반납하여 메모리 상태를 덤프한 것이다. 알고리즘이 정상적으로 동작하여 다시 0x400000 크기의 블럭이 생성되었음을 알 수 있다. 이를 반복해서 테스트하면 된다.

<0x20 메모리 블럭 해제 후>

6.마치면서...

동적 메모리 할당에 대해 구현하면서 멀티 태스킹 시에 발생할 수 있는 문제에 대한 고려는 제외하였다. 동적 할당에 대한 내용만으로도 충분히 복잡하기 때문에, 동기화 부분에 대해서는 다음에 다룰 것이다.

오늘 이후로 커널 코드에서 마음껏 malloc과 free를 사용할 수 있게 되었다. 비록 블럭 단위가 커서 효율성에 문제가 좀 있지만 프로그램을 주의해서 작성한다면 충분히 감당할 수 있는 부분이라 생각한다.

메모리 공간의 낭비가 마음에 걸린다면 동적 할당 알고리즘을 수정하면 된다. 버디 블럭의 크기를 512Byte 이하로 낮추는 것은 비트마스크의 크기가 커지므로 좋은 방법이 아니다. 괜찮은 방법은 아주 작은 메모리 블럭 같은 경우, 4Kbyte 크기를 버디 블럭으로 할당 받은 후 내부적으로 다시 비트 마스크를 사용하여 나누어 사용하는 것이다. 구현은 각자 해보도록 하자.

다음 번에는 멀티 태스크 환경에서 사용할 수 있도록 세머포어를 사용하여 동기화를 해보도록 하자.

7.첨부

7.1 프레임워크 1.0.3 버전 이전

Custom.zip : Custom 폴더의 파일들
makefile : makefile

7.2 프레임워크 1.0.3 버전 이후

Custom_1_0_3.zip

Part14. Tutorial2-멀티 태스킹(Multi Tasking) 기능을 추가해 보자

Tue, 13 Sep 2011 14:13:38 +0900

Part14. Tutorial2-멀티 태스킹(Multitasking) 기능을 추가해 보자

원문 : http://kkamagui.springnote.com/pages/353530

들어가기 전에...

이 글은 kkamagui에 의해 작성된 글입니다.
마음껏 인용하시거나 사용하셔도 됩니다. 단 출처(http://kkamagui.tistory.com, http://kkamagui.springnote.com)는 밝혀 주십시오.
기타 사항은 mint64os at gmail.com 이나 http://kkamagui.tistory.com으로 보내주시면 반영하겠습니다.
상세한 내용은 책 "64비트 멀티코어 OS 원리와 구조"를 참고하기 바랍니다.

0.시작하면서...

프레임워크에서 태스크 스위칭(Task Switching)을 구현하는 방법에 대한 내용은 참고. Multi Tasking 구현 방법에 설명해 놓았으니 참고하도록 하고, 여기서는 간단한 스케줄러를 구현하는 것을 목표로 하자.

1.태스크 스위칭(Task Switching) 관련 함수

00Kernel/Custom/KShell.c 파일을 열어보면 기본적인 태스크 스위칭 코드가 포함되어있다.

// Task를 저장한다.
TASK vstTask[ 2 ];char g_vcPrompt[8] = "[FRAME] ";
int g_iCurrentTask;
BOOL g_bScheduleStart = FALSE;
/**
    Timer Callback에서 수행되는 Scheduling 함수
*/
void Scheduler( void )
{
    if( g_bScheduleStart == FALSE )
    {
        return ;
    }
    g_iCurrentTask = abs( 1 - g_iCurrentTask );
    kSwitchTask( &( vstTask[ abs( 1- g_iCurrentTask ) ] ),
        &( vstTask[ g_iCurrentTask ] ) );
}
/**
    KShell 의 Main
*/
void Shell()
{
    // Task 설정 kSetupTask( &( vstTask[ 0 ] ), ShellLoop, NULL );kSetupTask( &( vstTask[ 1 ] ), EdgeDraw, NULL );    g_iCurrentTask = 0;
    g_bScheduleStart = TRUE;
ShellLoop();
}

위의 파란색 부분이 스위칭에 관련된 부분이다. Shell() 함수와 Scheduler() 함수를 보면 2개의 태스크를 설정하고 두 태스크를 번갈아가면서 호출하는 것을 알 수 있다. 여기서 눈여겨 봐야 하는 함수 2개는 kSetupTask()와 kSwitchTask() 이다(참고. 프레임워크 주요 함수들 내용 참고).

kSetupTask() : 태스크 구조체와 태스크의 엔트리 포인트, 그리고 태스크 종료 시 호출될 함수의 엔트리 포인트를 받아서 태스크를 설정하는 역할 수행. 태스크 구조체를 생성하는 함수
kSwitchTask() : 현재 수행중인 태스크를 저장할 태스크 구조체와 다음에 실행할 태스크를 로드할 태스크 구조체를 받아서 두개를 스위칭하는 역할 수행. 태스크 스위칭을 수행하는 함수

kSetupTask() 함수의 마지막 파라메터는 NULL로 설정가능한데, 디폴트 태스크 종료 핸들러를 부르겠다는 의미로 사용된다.

디폴트로 설정된 태스크 종료 함수는 kEndTask()로 설정되어있고 아래와 같다.

/**
    Task의 종료 처리
*/
void kTaskEnd( void )
{
    // 필요한 뭔가를 하자
    while( 1 ) ;
}

만약 위의 무한 루프 코드를 삭제하면 어떻게 될까? 그럼 kTaskEnd() 함수에서 return을 하게되는데 이때 스택은 Top이 Bottom을 지나가게되고 알 수 없는 곳으로 점프하여 이상한 코드를 실행하게 될 것이다. 운이 좋으면 수십초 정도 지나서 Fault가 발생할 것이고, 운이 나쁘면 점프한 즉시 Fault가 발생하여 커널이 정지 된다. @0@)/~

이런 수습이 불가능한 상황을이 되기전에 막아야 하므로, 디폴트 핸들러는 무한 루프를 실행하여 다른 곳으로 가지 못하게 한다.

2.간단한 스케줄러 설계

자 이제 간단한 스케줄러에 대한 이야기를 해보자. 우리가 만들 스케줄러는 아래와 같다.

라운드로빈(Round-Robin)의 알고리즘을 이용
태스크의 수는 최대 30개(왜? 너무 크면 커널 스택을 넘어서기때문)
태스크 리스트의 형태는 링크드 리스트(Linked List)의 형태
타이머 인터럽트를 이용

그럼 이제 구현을 위해 수정해야할 부분을 하나하나 살펴보자.

3.구현

3.1 Task.c/h 파일 수정

일단 태스크 구조체를 조금 수정해서 태스크를 링크드 리스트의 형태로 만들 수 있도록 하자. FW/Task.h 파일을 열어서 TASK 구조체가 아래와 같이 되어있는 지 확안하고 그렇지 않다면 수정하자.

// Task에 대한 정보 저장
typedef struct kTaskStruct
{
// Stack의 15DWORD를 Register를 저장하는데 사용한다.
DWORD vdwStack[ MAX_STACKSIZE ];
int iTID;
struct kTaskStruct* pstNext;
} TASK, *PTASK;

언제나 그렇듯이 파란색 부분이 주의깊게 볼 부분이다. 태스크 구분을 위한 iTID를 추가하고 다음 태스크 구조체를 연결하기위한 pstNext 부분을 추가했다.

아래 함수는 FW/Tash.c 파일에 포함된 함수인데, 태스크 구조체, 태스크 시작 엔트리 포인트, 태스크 종료 엔트리 포인트를 받아서 태스크 구조체를 설정하는 함수이다. Task가 종료되었을 때 불리는 함수를 설정하는 부분에 버그가 있어서 붉은색 부분을 수정했다. 붉은색 부분을 확인하자.

/**
TASK 구조체를 설정한다.
*/
BOOL kSetupTask( PTASK pstTask, void* pfStartAddr, void* pfEndAddr ){
DWORD* pdwStackTop;
// 구조체를 초기화 한다.
kMemSet( pstTask, 0, sizeof( pstTask->vdwStack ) );
// Stack의 Top
pdwStackTop = ( DWORD* ) ( pstTask->vdwStack + ( MAX_STACKSIZE - 1 ) );
    // ESP, EBP, EFLAG, EAX, EBX, ECX, EDX, ESI, EDI 순으로 Push 한다.
    pstTask->vdwStack[ 14 ] = ( DWORD ) ( pdwStackTop - 1 );
    pstTask->vdwStack[ 13 ] = ( DWORD ) ( pdwStackTop - 1 );
    pstTask->vdwStack[ 12 ] = EFLAG_DEFAULT;
    // cs, ds, ss, es, fs, gs는 kernel의 기본값으로 설정해 준다.
    pstTask->vdwStack[ 5 ] = GDT_VAR_KERNELCODEDESC;
    pstTask->vdwStack[ 4 ] = GDT_VAR_KERNELDATADESC;
    pstTask->vdwStack[ 3 ] = GDT_VAR_KERNELDATADESC;
    pstTask->vdwStack[ 2 ] = GDT_VAR_KERNELDATADESC;
    pstTask->vdwStack[ 1 ] = GDT_VAR_KERNELDATADESC;
    pstTask->vdwStack[ 0 ] = GDT_VAR_KERNELDATADESC;
    // 마지막으로 Stack의 Return Address를 pfAddr로 설정해 준다.
    pdwStackTop[ -1 ] = ( DWORD ) pfStartAddr;
    // 만약 Task 종료 함수가 설정되지 않으면 Default를 설정
    if( pfEndAddr != NULL )
    {
        pdwStackTop[ 0 ] = ( DWORD ) pfEndAddr;
    }
    else
    {
        pdwStackTop[ 0 ] = ( DWORD ) kTaskEnd;
    }
    return TRUE;
}

3.2 Scheduler.c/h 파일 추가

Custom/Scheduler.c/h 파일은 스케줄러의 구현이 들어갈 파일이다. KShell.c 파일에 스케줄러를 구현해도 되지만 코드가 길어지고 쉘과는 크게 관계 없는 부분이므로 따로 구현하는게 좋다.

아래의 코드는 Scheduler.h에 포함된 스케줄러 관련 구조체이다. 스케줄러의 태스크 관리 부분은 태스크의 pstNext 필드를 이용하여 링크드 리스트(Linked List)를 이용해서 구현했다.

// 개수를 너무 크게 설정하면 4M 이상으로 넘어가버린다.
// 그렇게 되면 커널 스택이 데이터를 덮어쓰게 되서 문제가 발생하므로 적당히 조절해야한다.
#define MAX_TASKCOUNT 30
// 스케줄러 구현을 위한 태스크 정보를 포함한 구조체
typedef struct SchedulerStruct
{
    int iTaskCount;

    // 리스트의 헤더
    TASK* pstHeader;

    // 플래그 변수들
    BOOL bEnableScheduler;
    BYTE bLock;

    // 현재 수행중인 태스크 ID
    int iCurrentTID;

    // 태스크 저장을 위한 공간
    BOOL vbAlloc[ MAX_TASKCOUNT ];
    TASK vstTask[ MAX_TASKCOUNT ];
} SCHEDULER,* PSCHEDULER;

태스크를 추가하고 삭제하는 것에 대한 세부 내용은 그리 어렵지 않으므로 첨부파일을 살펴보도록 하고, 약간의 트릭이 가미된 부분을 중점적으로 살펴보자.

스캐줄러를 구현할 때마다 고민하는 부분이기도 한데... 구현에 문제가 되는 부분이 태스크가 자신의 ID를 알아내는 방법이다. 태스크가 자신의 ID 즉 TID가 얼마인지 어떻게 알까? 가장 쉬운 방법은 스케줄러가 현재 태스크의 ID를 글로벌 변수 같은데 저장하고 태스크가 그 변수에 접근해서 읽는 것이다.

이 방식을 사용한다면 태스크 스위칭 시에 글로벌 변수에서 자기 ID를 읽어온 뒤에 다음 태스크를 검색하여 찾고, 스위칭 하기 전에 글로벌 변수에 다음 태스크 번호로 업데이트한 후 스위칭을 완료해야 한다. 왜냐하면 스케줄러가 호출되고 난 뒤는 이미 다른 태스크로 스위칭된 상태이므로 중단되었다가 복원된 태스크가 갑자기 글로벌 변수에 현재 TID를 바꾼다는 것은 기대하기 힘들다.

그럼 여기서 발생하는 문제!!! 타이머에서 스케줄러 함수를 호출하고 태스크도 수시로 스케줄러 함수를 호출하면 어떻게될까?

별 다른 처리를 하지 않았다면... 정답은 "엉망이 된다" 이다. ㅡ_ㅡ;;;; 아래 코드를 한번 보자.

/**
    다른 태스크를 실행시킨다.
*/
void SwitchTask( void )
{
    TASK* pstCurTask;
    TASK* pstNextTask;
    pstCurTask = &( gs_stScheduler.vstTask[ GetCurrentTID() ] );
    pstNextTask = pstCurTask->pstNext;
    if( pstNextTask == NULL )
    {
        pstNextTask = gs_stScheduler.pstHeader;
    }
    gs_stScheduler.iCurrentTID = pstNextTask->iTID;
kSwitchTask( pstCurTask, pstNextTask );
}

위의 상황을 실제 코드에서 시뮬레이션 한번 해보자. 커널에 총 3개의 태스크가 존재한다고 생각하고 현재 태스크를 T1이라 하고 T1의 다음 태스크를 T2, T2의 다음 태스크를 T3라고 가정하자.

태스크가 스케줄러 함수를 호출해서 위의 파란라인까지 실행한다음, 타이머에 의해서 다시 스케줄링이 되면 어떻게 될까? 아직 태스크 스위칭 함수가 호출되지 않은 상태에서 글로벌 변수인 gs_stScheduler.iCurrentTID 값이 T2로 바뀐 상태이므로 타이머에 의해서 스케줄러가 호출되었을 때는 T2의 태스크 구조체에 T1의 태스크를 저장하게 되고 복원되어 실행되는 태스크는 T3가 된다.

순식간에 T2 태스크가 사라져 버렸다. 그리고 다시는 T2 태스크를 볼 수 없을 것이다.

실제로 이 코드를 그대로 돌려보면 아래와 같은 기분좋은(??) 크래쉬 화면을 볼 수 있다(General Fault는 코드 실행 시에 발생한 Exception을 의미한다).

<프레임워크 크래쉬 화면>

정상적으로 실행하기위해서 코드를 어떻게 수정해야 할까? 해결책은 간단하다. 위 코드를 하나의 태스크만 실행하도록 수정하면 된다. 가장 간단한 방법으로는 위 코드의 시작부터 끝까지를 인터럽트 불가로 설정하면 된다. 이렇게 하면 실행에는 문제가 없지만 스위칭을 할때마다 인터럽트가 불가가되니 인터럽트 처리에 문제가 생길 수 있다(인터럽트 지연이 발생한다).

그럼 다른 방법은 없는걸까? 조금만 더 생각해 보면 인터럽트를 불가해야 하는 부분을 줄일 수 있다. 크게 두가지 부분으로 나눌 수 있는데, 첫번째 부분은 스케줄링 함수를 중복으로 호출하지 못하게 하여 처리할 수 있는 부분이고, 두번째 부분은 인터럽트 불가로 해결해야하는 부분이다.

/**
    다른 태스크를 실행시킨다.
*/
void SwitchTask( void )
{
    TASK* pstCurTask;
    TASK* pstNextTask;
    DWORD dwFlags;
    // Scheduler를 다른곳에서 호출 못하도록 Lock을 건다.
    if( kLock( &gs_stScheduler.bLock ) == FALSE )
    {
        return ;
    }
    pstCurTask = &( gs_stScheduler.vstTask[ GetCurrentTID() ] );
    pstNextTask = pstCurTask->pstNext;
    if( pstNextTask == NULL )
    {
        pstNextTask = gs_stScheduler.pstHeader;
    }
    gs_stScheduler.iCurrentTID = pstNextTask->iTID;
    // 플래그 레지스터를 저장하고, 인터럽트를 불가로 설정한다.
    dwFlags = kReadFlags32();
    kClearInt();
kUnlock( &gs_stScheduler.bLock );
    kSwitchTask( pstCurTask, pstNextTask );
    // 플래그 레지스터를 복원하여 이전 인터럽트 플래그를 복구한다.
    kWriteFlags32( dwFlags );
}

위 부분에서 푸른색 부분이 태스크 스위칭을 중복으로 허용하지 않으면 해결할 수 있는 부분이다. 주의해서 볼 것은 붉은 색 부분인데, 이 부분은 인터럽트와 관련된 부분으로 인터럽트 불가를 설정한 뒤 스위칭을 하고 다시 원래의 인터럽트 플래그를 복원하는 코드이다.

이렇게하면 혹시나 현재 저장된 이 태스크가 다시 복원되어 플래그 레지스터를 복원하기 전까지는 인터럽트가 불가가 되는게 아닐까? 너무 위험한 생각이 아닐까?

그렇지 않다. 태스크 스위칭 함수를 호출했을 때 복원되고 저장되는 레지스터중에 EFLAG 레지스터(인터럽트나 각종 상태가 저장되어있는 레지스터)가 포함되어 있기 때문이다. 다시 말해 태스크 별로 인터럽트 가능/불가 플래그를 가지고 있으므로 다른 태스크를 복원했을 때 복원한 태스크가 인터럽트 가능 상태였다면 EFLAG 레지스터 복구를 통해 자연스럽게 가능 상태로 설정된다.

만약 이것을 kUnlock() 함수를 호출해서 태스크 스위칭 불가 플래그를 풀어주는 방법으로 구현한다고 생각해보자. 태스크를 복원했을 때 제일 처음 해야 할일이 kUnlock()을 호출하는 일이기 때문에 여러가지 꼼수를 사용해서 이를 처리해야 하는데 굉장히 복잡하다.(한번 상상을 해보자... 어떻게 구현할 것인지.. ㅡ,.ㅡ;;;).

플래그(EFLAG) 레지스터는 태스크 스위칭을 하면서 복원되기 때문에 아주 간단하게 인터럽트 불가 영역을 줄이면서 동기화의 문제를 해결할 수 있다.

뭐 사실 지금 상황에서 인터럽트 불가 영역을 줄이는게 큰 의미가 있겠냐고 의문을 가지는 사람이 있을지도 모르겠다. 스케줄러 전 영역을 태스크 불가로 만들어도 괜찮겠다고 생각하는 사람은 스케줄러 코드가 수십줄이 아니라 수천줄일 때도 괜찮을지 생각해 보기 바란다. 이런 복잡한 스케줄러 코드에서 스케줄러 함수의 시작부터 끝까지 인터럽트를 불가를 한다면? 결과는 상상에 맡기겠다 @0@)/~

kLock()과 kUnlock() 함수는 Atomic Operation으로 플래그의 값을 변경해주고 그 결과를 리턴값으로 나타내는 함수이다. Atomic Operation은 해당 역할을 끝내기 전에 다른 이유로하여 중단됨이 없다는 것을 보장하는 동작이다. 따라서 세머포어(Semaphore)나 뮤택스(Mutex)와 같은 동기화 객체 구현에 많이 사용된다.

kClearInt() 함수와 kReadFlags32(), kWriteFlags32() 함수는 플래그(EFLAG) 레지스터와 관련된 함수인데 Intel Architecture에 관련된 부분이라서 자세하게 설명하진 않겠다. 자세한 것은 참고. 프레임워크 주요 함수들과 Part5. Intel Architecture에 대한 소개 문서를 참고하자.

스케줄러의 전체 파일은 아래에 첨부했다.

3.3 KShell.c/h 파일 수정

테스트용 코드가 삽입되어있던 부분을 스케줄러 파일로 다 옮기고 간단히 수정한다. 쉘의 전체 파일은 아래의 코드 첨부를 통해 다운 받도록 하자.

/**
    KShell 의 Main
*/
void Shell()
{
    // 초기화
    InitScheduler();
// 새로운 태스크 등록
AddTask( EdgeDraw );
    EnableScheduler( TRUE );
    // Shell의 실행
    ShellLoop();
while( 1 );
}

3.4 makefile 파일 수정(프레임워크 1.0.3 버전 이전)

프레임워크 1.0.3 버전 이전 사용자는 makefile을 수정해 주어야 한다. Scheduler.c/h 파일을 추가했으니 makefile을 수정하자.

# 응용 프로그램 파일
FW.o : $(CUSTOMDIR)Framework.c
$(GCC) -o FW.o $(CUSTOMDIR)FrameWork.c
KShell.o : $(CUSTOMDIR)KShell.c
$(GCC) -o KShell.o $(CUSTOMDIR)KShell.c
Sched.o : $(CUSTOMDIR)Scheduler.c $(GCC) -o Sched.o $(CUSTOMDIR)Scheduler.c
#Object 파일 이름 다 적기
#아래의 순서대로 링크된다.
OBJ = A.o K.o Is.o D.o Int.o Key.o Stdlib.o Task.o FW.o KShell.o Sched.o

Scheduler.c 파일을 추가했으니 makekernel.bat를 실행해 보자.

4.마치면서...

이번에 스케줄러 코드를 추가하면서 그 동안 숨겨져왔던 코드들의 버그가 속속들이 드러났다. 디버깅한다고 혼쭐이 났는데... 고생한걸 생각하면 눈물이.. ㅜ_ㅜ...

기념으로 스크린 샷 하나 올린다. starttask 명령과 showtask 명령이 추가되었다. starttask 함수는 EdgeDraw 태스크를 실행해주는 역할을 하고, showtask 함수는 현재 동작중인 태스크의 개수를 리턴하는 역할을 한다.

<멀티 태스킹 실행 화면>

5.첨부

5.1 프레임워크 1.0.3 버전 이전

프레임워크 1.0.3 버전 이전 파일이다. 다운 받아서 덮어쓰면 된다(기존 코드의 버그도 같이 수정했다).

Custom.zip : Custom 폴더의 파일들
FW.zip : FW 폴더의 파일들
makefile : Scheduler 파일 빌드용 makefile

5.2 프레임워크 1.0.3 버전 이후

프레임워크 1.0.3 버전 이후 파일이다. 다운 받아서 덮어쓰면 된다.

Custom_1_0_3.zip

kkamagui의 작업실

13 Git 사용법

13.Git 사용법

들어가기 전에...

1.Git에 user.name과 user.email 설정

2.Git에 설정된 global config 값들 표시

3.표시되는 메시지를 컬러로 보기

4.문자셋 설정하기

5.내장 도움말 보기

6.Git Project 생성하기

7.저장소에 파일 추가하기

8.저장소의 상태 확인하기

9.변경사항 로컬 저장소에 저장하기

10.변경 이력 보기

kkamagui의 작업실

KKAMAGUI의 작업실 >ㅁ<)/~

블로그 사이트를 티스토리로 이동했습니다. ^^ http://kkamagui.tistory.com, http://www.mint64os.pe.kr

목록

프로그래밍 외

16 VI 관련

1.우분투에서 VI에 Taglist 설치 방법

2.Keymapping 바꾸는 방법

3.Ruby syntax 관련 플러그인 설치 방법

4.한글 인코딩 자동으로 해주는 방법

5.폰트 설정 방법

6.내 VI 설정

7.문자열 치환 방법

12 루비(Ruby) 프로그래밍

*.화면 출력

*.Array 다루기

*.제어문

1.Case문

2.Loop

3.가변 인자

4.정규표현식

*.Code Block 사용법

*.화면 입출력

5.if문

0.두 개 이상의 리턴값 전달하기 및 받기

*.class 처리

20 프로그래밍 팁

소개

00 포트폴리오(Portfolio)

00 포트폴리오(Protfolio)

00 KKAMAGUI 소개

이사한 소감

KKAMAGUI 소개

나의 행적...

병역 특례 후(2006 ~ 현재)

병특 시절(2002 ~ 2006 초)

병특 시절 이전( ~2002)

03 비디오 모드 제어(Video Mode Control)

03 비디오 모드 제어(Video Mode Control)

들어가기 전에...

0.시작하면서...

1. Display Control

1.1 GBA Display Control Register

1.2 NDS Display Control Register

1.3 BG Mode Detail

1.4 Object

2. VRAM Control

2.1 VRAM의 종류 및 컨트롤 모드

2.2 세부 모드별 VRAM 설정

3. Background Control

3.1 Background Control Register

3.2 Background Scrolling Register

3.3 Background Rotation/Scaling Register

4. Window Register

5. 사용 예제

5.1 화면 스크롤

5.2 더블 버퍼링

5.3 인터럽트(Interrupt)

6. 첨부

Part15. Tutorial3-동기화(Synchronization) 기능을 추가해 보자

Part15. Tutorial3-동기화(Synchronization) 기능을 추가해 보자

들어가기 전에...

0.시작하면서...

1.동기화 객체(Synchronization Object)

2.세머포어(Semaphore) 설계

3.구현