블로그 이미지
No pain, no gain!
lepoussin

Tag

Notice

Recent Post

Recent Comment

Recent Trackback

Archive

calendar

1 2 3 4
5 6 7 8 9 10 11
12 13 14 15 16 17 18
19 20 21 22 23 24 25
26 27 28 29 30 31
  • total
  • today
  • yesterday
01-20 14:20
2007. 3. 6. 03:33 OS/Linux

  1. 일단 cdrom이 마운트 되었는지 확인. #mount /dev/cdrom
  2. vmware위 메뉴창에서 VM -> install vaware tools 한다.
  3. 아무 디렉토리나 만든다. #mkdir ~/temp
  4. 마운트 #mount /dev/cdrom ~/temp
  5. 찾아 들어간다. #cd ~/temp
  6. ls 해서 vmware-tools.rpm 확인하고 인스톨 #rpm -Uvh vmware-tools.rpm
  7. 기다리다가 다 인스톨되면 #cp /etc/X11/xorg.conf /etc/X11/XF86Config
  8. #vmware-config-tools.pl 실행
  9. 윈도우에서 시작에서 해상도 변경해도 되고 기본값이 800*600 이므로 그냥 쓰면 됨
  10. 재부팅 #shutdown -r now

posted by lepoussin
1) 캐시의 목적 : 느린 메모리 때문에 발생되는, 프로세서 코어에 가해지는 메모리 액세스 병목 현상(bottleneck)의 감소
2) 쓰기 버퍼
  - 프로세서 코어와 주 메모리 사이에 놓여 있는 매우 작은 FIFO 메모리
  - 주메모리에 쓰는 것과 관련된 느린 쓰기 시간으로부터 프로세서 코어와 캐시 메모리를 자유롭게 하는데 있음.
3) 캐시의 단점 : 프로그램의 실행 시간을 결정하기가 어려워진다.

12.1 메모리 계층 구조와 캐시 메모리
  1) 메모리 계층 구조 : 주변의 기술에 의존해 있기 때문에 아키텍처 설계에 많이 의존
    - 칩 : 프로세서 코어 내 레지스터 파일
    - 보드 : 주메모리(TCM, SRAM, DRAM, 플래시와 다른 보드 레벨 비휘발성 메모리)
    - 디바이스 : 보조 기억 장치(디스크, 테이프, 네트워크 저장 장치)
  2) 캐시 메모리
    - 레벨(L1) 캐시(기본 캐시) : 가장 낮은 레벨에서부터 코드와 데이터를 임시로 저장하는 고속의 온칩 메모리
    - 레벨(L2) 캐시(보조 캐시) : L1 캐시와 더 느린 메모리 사이에 위치
    - 쓰기 버퍼 : 캐시로부터 주메모리에 쓰기를 지원하는 매우 작은 FIFO 버퍼
    - 캐시 라인 : 주메모리와 캐시의 관계에서 더 느린 주메모리 사이에 전송하는 데이터의 작은 블록

12.1.1 캐시와 메모리 관리 장치
  1) 논리 캐시(가상 캐시)
    - 가상 주소 공간 안에 데이터를 저장
    - 프로세서와 MMU 사이에 위치
    - StrongARM, XScale, 제품군 ARM7 ~ ARM10
  2) 물리 캐시
    - 물리 주소를 사용해서 메모리에 저장
    - MMU와 주메모리 사이에 위치
    - 프로세서가 메모리를 액세스하기 위해서는 MMU는 먼저 가상 주소를 물리 주소로 변경해야 함
    - ARM11 제품군
  3) 캐시의 의한 성능 향상
    - 가능 이유 : 컴퓨터 프로그램이 랜덤하지 않은 방식으로 실행되기 때문(예측 가능)
    - 참조의 지역성 : 컴퓨터 소프트웨어 프로그램은 데이터 메모리의 집약되어 있는 부분에서 작은 코드들이 반복적으로 실행
    - 시간과 공간에서의 반복적인 국부적 참조성을 사용 : 시간적 지역성(temporal locality), 공간적 지역성(spatial locality, 주소의 근접성에 의해 참조)

12.2 캐시 아키텍처
  1) 폰노이만 아키텍처 : 통합 캐시(uified cache)
  2) 하버드 아키텍처 : 분할 캐시(split cache)
  3) 캐시의 주요 요소
    - 캐시 컨트롤러 : 캐시 메모리의 일부분을 선택하기 위해 메모리를 요청하는 동안 프로세서에 의해 이슈되는 주소의 다른 부분을 사용
    - 캐시 메모리 : 캐시 라인이라는 장치 안에서 액세스되는 전용 메모리 열

12.2.1 캐시 메모리의 기본 아키텍처
  1) 캐시 라인의 구성
    - 디렉토리 저장소(directory store) : 주메모리에서 캐시 라인으로 복사된 주소를 구분하기 위해서 이용(디렉토리 엔트리는 캐시 태그(cache-tag))
    - 데이터 영역
    - 상태 정보 영역
  2) 캐시의 크기 : 캐시가 주메모리에서 저장할 수 있는 실제 코드나 데이터로 정의(캐시 태그와 상태 비트는 캐시 크기 안에 포함 안됨)
  3) 상태 비트
    - 유효 비트(valid bit) : 캐시 라인이 활성화되어 있음을 표시하기 위한 것
    - 더티 비트(dirty bit) : 캐시 라인이 주메모리 안에 저장되어 있는 값과 다른 데이터를 포함하고 있는지 아닌지를 결정

12.2.2 캐시 컨트롤러의 기본 동작
  1) 캐시 컨트롤러 : 주메모리에서 캐시 메모리로 코드나 데이터를 자동으로 복사해주는 하드웨어
    - 요청 처리 : 요청한 주소를 태그(tag), 세트 인덱스(set index), 데이터 인덱스(data index)를 나누어서 처리
    - 처리 과정
      ① 필요로 하는 캐시 메모리의 캐시 라인을 찾기 위해 세트 인덱스 이용
      ② 유효 비트 확인, 요청된 주소의 태그 영역과 캐시 태그 비교 → 모두 성공 시 캐시 적중(hit), 둘 중에 하나가 실패할 경우 캐시 미스(miss)
      ③ 캐시 미스시, 컨틀로러는 주메모리에서 모든 캐시 라인을 캐시 메모리로 복사하고 요청된 코드나 데이터를 프로세서에 보냄
        ※ 캐시 라인 채우기(cache line fill) : 캐시 라인을 주메모리에서 캐시 메모리로 복사하는 것
      ④ 캐시 적중시, 컨트롤러는 캐시 메모리에서 프로세서로 직접 코드 또는 데이터를 공급

12.2.3 캐시와 주메모리 사이의 관계
  1) 데이터 스트림 : 캐시 라인을 채우는 동안 캐시 컨트롤러가 이것을 캐시에 복사하면서 동시에 코어에 데이터를 로딩할 수 있는 것
  2) eviction : 캐시 미스가 발생하여 기존의 캐시 라인을 제거하는 과정
  3) 스래싱 : 캐시 메모리 안에 동일한 위치에 대한 소프트웨어 병목 현상

12.2.4 세트 연상
  1) 세트 연상 : 세트 인덱스가 가리키는 캐시 라인의 세트
  2) 세트 연상 증가
    - 연상이 증가할때마다 스래싱의 가능성이 감소, 대신 지원하는 하드웨어의 복잡도도 증가
    - 완전 연상 캐시(fully associative cache) : 캐시의 세트 연상을 최대화하여 설계된 캐시
    - CAM(content addressable memory) : 각각의 유효한 캐시 라인 안에 저장되어 있는 캐시 태그와 입력 태그 주소를 비교하는 비교기 세트를 사용 → 더 많은 캐시 태그를 동시에 비교할 수 있으므로 한 세트 안에 포함될 수 있는 캐시 라인의 수를 늘릴 수 있음

12.2.5 쓰기 버퍼 : 프로세서가 주메모리에 쓸 데이터를 임시로 저장하고 있는 작고 빠른 FIFO 메모리 버퍼
  - 실행되는 명령어 수에 대한 주메모리 쓰기 비율에 따라 효과가 달라짐
  - 쓰기 버퍼로 인한 캐시 성능 향상 : 더티 캐시 라인 제거시 주메모리 대신 쓰기 버퍼에 캐시 라인 쓰여짐 → 새로운 캐시 라인 데이터 사용이 빨라짐
  - 엄격한 FIFO 버퍼가 아닐 수 있음 ex) ARM 10 제품군 : 합성(coalescing) 방식 지원

12.2.6 캐시 효율성 측정
  1) 적중률
    - 적중률 = (캐시 적중 수 / 메모리 요청 수) x 100
    - 미스율 = 100 - 적중률
    - 읽거나 쓰거나 또는 둘 다를 측정하는데 사용될 수 있음
  2) 측정 관련된 다른 용어
    - 적중 시간(hit time) : 캐시에서 어떤 메모리 위치를 액세스하는 데 걸리는 시간
    - 미스 패널티 : 주메모리에서 캐시로 캐시 라인을 로드하는 데 걸리는 시간

12.3 캐시 정책
  1) 쓰기 정책(write policy) : 프로세서가 쓰기 동작을 할 때, 데이터를 어디에 저장할지를 결정
  2) 교체 정책(replacement policy) : 캐시 미스가 발생하였을 때, 다음 라인을 채우는 데 사용될 세트 안에 있는 캐시 라인을 선택
  3) 할당 정책(allocation policy) : 캐시 컨트롤러가 캐시 라인을 언제 할당할 지를 결정

12.3.1 쓰기 정책 : 후기입 방식 또는 연속기입 방식
  1) 연속기입 방식
    - 저장할 때 캐시가 적중이라면 캐시와 주메모리에 모두 값을 저장
  2) 후기입 방식
    - 유요한 캐시 데이터 메모리에만 저장하고 주메모리에는 저장하지 않는다.
    - 연속기입 방식보다 성능 우수 ex) 서브루틴에 의해 임시 지역 변수를 반복적으로 사용할 때

12.3.2 캐시 라인 교체 정책
  1) 캐시 라인 교체
    - victim : 교체를 위해 선택된 캐시 라인
    - eviction : victim 캐시 라인을 선택하고 교체하는 과정
  2) 교체 방식
    - 의사 랜덤 방식(pseudorandom) : 캐시 컨트롤러가 무작위로 증가값을 선택하고 이를 victim 카운터에 더해서 증가시킴
    - 라운드 로빈 방식 : 캐시 컨트롤러가 캐시 라인을 할당할 때마다 순차적으로 증가하는 victim 카운터 사용
    - LRU(Least Recently Used) 방식 : 캐시 라인의 사용에 대해 조사해본 다음, 가장 오랜 시간 동안 사용되지 않는 캐시 라인을 다음의 victim으로 선택

12.3.3 캐시 미스시의 할당 정책
  1) 할당 방식
    - read-allocate : 주메모리에 읽는 동안 캐시 라인을 할당
    - read-write-allocate : 메모리를 읽고 쓰기 위해서 캐시 라인을 할당

12.4 코프로세서 15와 캐시
  - CP15:c7(+ c5, c6, c7, c10, c13, c14): 쓰기만 가능, 캐시를 클린(clean)하고 플러시(flush)하는데 사용
  - CP15:c7(+ c10) : 드레인 쓰기 버퍼
  - CP15:c9(+ c0) : victim 포인터 베이스 주소를 정의, 캐시 안에서 락(lock)되어 있는 코드 또는 라인수를 결정
  - CP15:c15(+ c0) : 라운드 로빈 교체 정책

12.5 캐시 메모리의 플러시와 클린
  1) 캐시 플러시 : 유효한 캐시 라인 안에 있는 유효 비트를 0으로 클리어시키는 것
  2) 캐시 클린 : 캐시로부터의 더티 캐시 라인의 값을 강제로 주메모리에 쓴 다음, 캐시 라인 안에 있는 더티 비트를 0으로 초기화하는 것 → 캐시된 메모리와 주메모리 사이의 일관성 재정립
  3) 시스템의 메모리 설정을 변경하거나 불할 캐시 안에서 자체 수정 코드를 실행하기 전에 클린이나 플러시를 해줄 필요가 있다.

12.5.1 ARM 캐시 코어 플러시하기

12.5.2 ARM 캐시 코어 클린하기

12.5.3 D 캐시 클린

12.5.4 WAY 및 세트 인덱스 어드레싱을 사용해서 D 캐시 클린하기

12.5.5 테스트 클린 명령어를 사용해서 D 캐시 클린하기

12.5.6 인텔 XScale SA-110과 인텔 StrongARM 코어에서 D 캐시 클린하기

12.5.7 캐시의 일부분을 클린하고 플러시하기

12.6 캐시 락다운 : 프로그램이 시간에 민감한 코드와 데이터를 캐시 메모리에 로드하고, 이것을 eviction에서 면제되었음을 표시하는 것
  1) 목적 : 캐시 미스 문제를 피하기 위함
  2) 장단점
    - 장점 : 빠른 시스템 반응 제공
    - 단점 : 사용한 가능한 캐시 크기가 감소
  3) 캐시 안에서 락을 해주어야 하는 것들
    - 벡터 인터럽트 테이블
    - 인터럽트 서비스 루틴
    - 시스템이 배타적으로 사용하는 크리티컬한 알고리즘
    - 자주 사용되는 전역변수들
  4) 교체에서는 면제가 되지만 플러시에서는 면제가 안되어 캐시 메모리로 사용이 안되게 됨 → 캐시 락다운 루틴은 락다운 정보가 복원될 수 있도록 리턴이 필요

12.6.1 캐시 안에서 코드와 데이터 락하기

12.6.2 WAY 인덱스를 증가시켜 캐시 락하기

12.6.3 락비트를 사용하여 캐시 락하기

12.6.4 인텔 XScale SA-110에서 캐시 라인 락하기

12.7 캐시와 소프트웨어 성능
  1) 메모리 매핑된 주변 장치들은 캐시나 쓰기 버퍼를 사용하지 않도록 설정하는 것이 좋다.
  2) 자주 액세스하는 데이터는 메모리 안에 연속적으로 저장하려고 노력해야 한다.
  3) 코드 루틴을 작게 유지하고 관련된 데이터를 가까이에 함께 묶어두는 것이 좋다.
  4) 캐시를 효과적으로 활용하는 코드를 작성하는 것보다 시스템의 성능에 더 많은 영향을 끼치는 다른 요소들도 있다.
posted by lepoussin
2007. 3. 3. 00:49 Lecture/열혈강의 Python
1. 객체의 복사 : 같은 값을 가지는 객체를 하나 혹은 그 이상 만드는 것
  1) copy 모듈을 이용한 객체 복사
    - 얕은 복사(Shallow Copy) : 복합 객체를 별도로 생성하되 내용은 원래의 레퍼런스로 채운다.
>>> import copy
>>> a = [1, 2, 3]
>>> b = [4, 5, a]
>>> x = [a, b, 100]
>>> y = copy.copy(x)

    - 깊은 복사(Deep Copy) : 복합 객체를 생성하고 내용을 재귀적(Recursive)으로 복사한다.
>>> import copy
>>> a = [1, 2, 3]
>>> b = [4, 5, a]
>>> x = [a, b, 100]
>>> y = copy.deepcopy(x)


2. 형 변환
  1) 수치 형 변환
    - 정수형 변환 : int()
      ※ 실수→정수 : int(), round(), floor(), ceil()
    - 실수, 롱형으로의 형 변환 : float(), long()
    - 복소수로의 형 변환 : complex()
  2) 시퀀스 자료형 변환
    - 리스트로 변환 : list()
    - 튜플로 변환 : tuple()

>>> t = (1, 2, 3, 4)
>>> l = [5, 6, 7, 8]
>>> s = 'abcd'
>>>
>>> print list(t), list(s)
[1, 2, 3, 4] ['a', 'b', 'c', 'd']
>>> print tuple(l), tuple(s)
(5, 6, 7, 8) ('a', 'b', 'c', 'd')

  3) 문자열로의 형 변환
    - 비형식적인 문자열로 변환 : str()
    - 형식적인 문자열로 변환 : repr()
    - `obj` : repr(obj)와 동일
    ※ 객체 ↔ 문자열 : repr(str은 완벽한 변환 안됨), eval 사용

>>> L = ['파란 하늘', 'blue sky', 1, 1234L, 1/3.0]
>>> for s in L:
 print 's', s
 print 'str(s)', str(s)
 print 'repr(s)', repr(s)
 print '\'s\'', `s`
 print


s 파란 하늘
str(s) 파란 하늘
repr(s) '\xc6\xc4\xb6\xf5 \xc7\xcf\xb4\xc3'
's' '\xc6\xc4\xb6\xf5 \xc7\xcf\xb4\xc3'

s blue sky
str(s) blue sky
repr(s) 'blue sky'
's' 'blue sky'

s 1
str(s) 1
repr(s) 1
's' 1

s 1234
str(s) 1234
repr(s) 1234L
's' 1234L

s 0.333333333333
str(s) 0.333333333333
repr(s) 0.33333333333333331
's' 0.33333333333333331

  4) 문자열 요소를 가지는 리스트나 튜플을 문자열로 변환

>>> import string
>>> s = 'Python is the first language'
>>> L = s.split()
>>> L
['Python', 'is', 'the', 'first', 'language']
>>> ' '.join(L)
'Python is the first language'
  5) 리스트, 튜플과 사전의 변환
    - 사전에서 리스트로 변환
>>> d = {1: 'one', 2: 'two', 3: 'three'}
>>> d.keys()
[1, 2, 3]
>>> d.values()
['one', 'two', 'three']
>>> d.items()
[(1, 'one'), (2, 'two'), (3, 'three')]
    - 리스트에서 사전으로 변환
>>> keys = ['a', 'b', 'c', 'd']
>>> values = [1, 2, 3, 4]
>>> L = zip(keys, values)
>>> L
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> dict(L)
{'a': 1, 'c': 3, 'b': 2, 'd': 4}

  6) 문자 변환
>>> chr(97) # 아스키 코드 → 문자
'a'
>>> ord('a') # 문자 → 아스키 코드
97
  7) 임의의 진수를 10진수로 변환
>>> int('64', 16) # 16진수 '64'를 10진수로
100
>>> int('144', 8) # 8진수 '144'를 10진수로
100
>>> int('101111', 2) # 2진수 '101111'을 10진수로
47
>>> int('14', 5) # 5진수 '14'를 10진수로
9
  8) 10진수를 임의의 진수로 변환
    - 10진수에서 8, 16진수로
>>> hex(100) # 10진수 100을 16진수 문자열로 변환
'0x64'
>>> oct(100) # 10진수 100을 8진수 문자열로 변환
'0144'

    - 10 진수에서 2진수로

## 10진수 → 2진수

# @file int2bin1.py
octtab = {'0': '000', '1': '001', '2': '010', '3': '011',
    '4': '100', '5': '101', '6': '110', '7': '111'}

def bin1(d, width=0):
    "integer to binary(string)"
    s = "%o" % d
    b = ''
    for el in s:
        b += octtab[el]
    if width > 0:
        if len(s) > width:
            return b[:width]
        b = b.zfill(width)
    return b

print bin1(23, 7)   # 0010111

# @file int2bin2.py
def bin2(n, width=0):
    result = []
    while 1:
        result[:0] = [str(n&1)]
        n >>= 1
        if not n:
            break
    results = ''.join(result)
    if not width:
        width = len(results)
    return results.zfill(width)[:width]

print bin2(23, 7)
# 0010111

    - 10진수에서 임의의 진수로

## 10진수 → 임의의 진수
#  @param n 10진수
#  @param base 변환할 진수
#  @param width 출력 문자열 폭. 0이면 기본 값

def int2digit(n, base, width=0):
    res = ''
    while n > 0:
        n, r = divmod(n, base)
        if r > 9:
            r = chr(ord('a')+r-10)
        res += str(r)
    if not res:
        res = '0'
    if not width:
        width = len(res)
    return res.zfill(width)[:width]

print int2digit(70, 5)       # 240
print int2digit(70, 12)     # 5a
print int2digit(70, 15)     # 4a
print int2digit(70, 16)     # 46
print int2digit(70, 2, 8)   # 01000110

  9) 정수를 콤마가 있는 문자열로 변환

>>> import locale
>>> locale.setlocale(locale.LC_ALL, "") # 사용자 기본 환경(국가 혹은 언어)으로 설정
'Korean_Korea.949'
>>> print locale.format("%d", 10030405, 1)
10,030,405
posted by lepoussin