구조물에서 작은 값을 표현하는 가장 효율적인 방법은 무엇입니까?
종종 저는 아주 작은 가치들로 구성된 구조를 표현해야 한다는 것을 발견합니다.를 들면,면,Foo4개의 값을 갖습니다.a, b, c, d그것, 범위가 다양합니다.0 to 3
타이트 루프에 사용됨;
그들의 값은 초당 10억 번 읽히며, 그것이 프로그램의 병목 현상입니다.
의 되어 있습니다.
Foos;s;
그 는 , 를 하는 데 을 겪고 있습니다.Foo능률적으로 기본적으로 기본적으로 4가지 옵션이 있습니다.
struct Foo {
int a;
int b;
int c;
int d;
};
struct Foo {
char a;
char b;
char c;
char d;
};
struct Foo {
char abcd;
};
struct FourFoos {
int abcd_abcd_abcd_abcd;
};
128, , 8,합니다 당 각각 , 8, 8 비트를 합니다.Foo까지 첫 것입니다.을 사용하면 크기의 할 것이고, 않습니다첫 번째 예는 아마도 가장 언어적인 예일 것입니다. 하지만 이 예를 사용하면 본질적으로 프로그램 크기의 16배가 증가할 것입니다. 이는 제대로 된 것 같지 않습니다.게다가 대부분의 메모리가 제로로 채워져 전혀 사용되지 않을 것이기 때문에 이것이 낭비가 아닌가 하는 생각이 듭니다.반면에, 그것들을 빽빽하게 포장하는 것은 그것들을 읽는 데 추가적인 부담을 가져다 줍니다.
구조물에서 작은 값을 표현하기 위한 계산상 '가장 빠른' 방법은 무엇입니까?
읽기 오버헤드가 크지 않은 고밀도 패킹의 경우 비트 필드가 있는 구조를 추천합니다.예제에서 0에서 3 사이의 값이 4개인 경우 구조를 다음과 같이 정의할 수 있습니다.
struct Foo {
unsigned char a:2;
unsigned char b:2;
unsigned char c:2;
unsigned char d:2;
}
은 1 , 와 필드에 할 수 .foo.a,foo.b.
구조를 보다 촘촘하게 구성함으로써 캐시 효율성을 높일 수 있습니다.
편집:
코멘트를 요약하자면:
비트 필드에 대한 약간의 조작은 여전히 있지만, 컴파일러가 수행하기 때문에 수작업으로 작성하는 것보다 더 효율적일 가능성이 높습니다. 소스 코드가 더 간결하고 버그가 발생하기 쉬운 경향은 말할 것도 없습니다.그리고 처리하게 될 구조물의 양이 많다는 점을 고려할 때, 이와 같이 꽉 찬 구조물을 사용함으로써 얻게 되는 캐시 미스의 감소는 구조물이 부과하는 비트 조작의 오버헤드를 보충할 수 있을 것입니다.
공간이 고려 대상인 경우(예: 1,000,000개의 구조물 배열)에만 공간을 포장합니다.그렇지 않으면 이동 및 마스킹을 수행하는 데 필요한 코드가 데이터 공간 절약보다 큽니다.따라서 D캐시보다 I캐시에 캐시 미스가 발생할 가능성이 더 높습니다.
확실한 답은 없으며, "올바른" 선택을 할 수 있을 만큼 충분한 정보를 제공하지 않았습니다.트레이드 오프가 있습니다.
I/O 시간(예: 파일에서 데이터를 읽는 것)이 계산 효율성(예: 사용자가 "시작" 버튼을 누른 후 일부 계산 집합이 걸리는 시간)보다 더 중요한지 여부를 지정하지 않았기 때문에 "주요 목표는 시간 효율성"이라고 말하는 것은 불충분합니다.
또는 위해의 () 로 4 로 압축을 수 .int(따라서 이후 계산이 더 빨라집니다.)
또한, 그들이 그들을 보호할 수 있다는 것은 없습니다.int는 32비트(첫번째 패킹이 128비트를 사용한다고 문장에서 가정한 경우)입니다. Anint16비트일 수 있습니다.
Foo는 a, b, c, d의 4가지 값을 가지며 0에서 3의 범위를 갖습니다.보통은 상관없지만 가끔은 그 구조물들이...
다른 옵션이 있습니다. 값이 0이므로...3은 일종의 상태를 나타낼 가능성이 있으므로 "flags"를 사용하는 것을 고려해 볼 수 있습니다.
enum{
A_1 = 1<<0,
A_2 = 1<<1,
A_3 = A_1|A_2,
B_1 = 1<<2,
B_2 = 1<<3,
B_3 = B_1|B_2,
C_1 = 1<<4,
C_2 = 1<<5,
C_3 = C_1|C_2,
D_1 = 1<<6,
D_2 = 1<<7,
D_3 = D_1|D_2,
//you could continue to ... D7_3 for 32/64 bits if it makes sense
}
이는 대부분의 상황에서 비트 필드를 사용하는 것과 크게 다르지 않지만 조건부 논리를 크게 줄일 수 있습니다.
if ( a < 2 && b < 2 && c < 2 && d < 2) // .... (4 comparisons)
//vs.
if ( abcd & (A_2|B_2|C_2|D_2) !=0 ) //(bitop with constant and a 0-compare)
데이터에 대해 어떤 종류의 작업을 수행할 것인지에 따라 abcd를 4세트 또는 8세트로 사용하고 필요에 따라 끝을 0으로 패딩하는 것이 타당할 수 있습니다.이렇게 하면 최대 32개의 비교를 bitop과 0개의 비교로 대체할 수 있습니다.를 들어,어를 할 수 . 이 의 에 "트"다를든합니다.uint64_t abcd8 = 0x5555555555555555ULL;는 2다를 할 수 .abcd8 |= 0xAAAAAAAAAAAAAAAAULL;이제 을 3것 3으로 .
부록:추가적인 고려 사항을 위해 조합을 유형으로 사용하고 char 및 @dbush의 비트필드와 조합을 수행하거나(이러한 플래그 작업은 서명되지 않은 char에서 여전히 작동함) 각 a,b,c,d에 대해 char 유형을 사용하고 서명되지 않은 int와 조합할 수 있습니다.이렇게 하면 조합원이 어떤 조합원을 사용하느냐에 따라 콤팩트한 표현과 효율적인 운영이 가능합니다.
union Foo {
char abcd; //Note: you can use flags and bitops on this too
struct {
unsigned char a:2;
unsigned char b:2;
unsigned char c:2;
unsigned char d:2;
};
};
또는 더 멀리 확장되기도 합니다.
union Foo {
uint64_t abcd8; //Note: you can use flags and bitops on these too
uint32_t abcd4[2];
uint16_t abcd2[4];
uint8_t abcd[8];
struct {
unsigned char a:2;
unsigned char b:2;
unsigned char c:2;
unsigned char d:2;
} _[8];
};
union Foo myfoo = {0xFFFFFFFFFFFFFFFFULL};
//assert(myfoo._[0].a == 3 && myfoo.abcd[0] == 0xFF);
이 방법은 다른 방법의 다른 조합을 포함하기 위해 조합을 사용하는 경우에도 문제가 될 수 있는 일부 엔디안 차이를 도입합니다.
union Foo {
uint32_t abcd;
uint32_t dcba; //only here for endian purposes
struct { //anonymous struct
char a;
char b;
char c;
char d;
};
};
다른 조합 유형과 알고리즘으로 실험하고 측정하여 조합의 가치가 있는 부분을 확인한 후 유용하지 않은 부분은 폐기할 수 있습니다.여러 char/short/int 유형에서 동시에 작동하는 경우 AVX/simd 명령어의 일부 조합에 자동으로 최적화되는 반면 비트 필드를 사용하는 경우 수동으로 롤을 해제하지 않는 한...테스트하고 측정하기 전에는 알 방법이 없습니다.
데이터 세트를 캐시에 맞추는 것은 매우 중요합니다.하이퍼스레딩은 하드웨어 스레드 간에 코어당 캐시를 경쟁적으로 공유하기 때문에(Intel CPU의) 작은 것이 항상 더 좋습니다.이 답변에 대한 의견에는 캐시 미스 비용에 대한 몇 가지 수치가 포함되어 있습니다.
x86에서 부호 또는 0 확장자가 있는 8비트 값을 32비트 또는 64비트 레지스터에 로드하는 것 (movzx아니면movsx는 말 는.mov바이트 또는 32비트 d워드의.32비트 레지스터의 낮은 바이트를 저장하는 것도 오버헤드가 없습니다.(여기서는 Agner Fog의 설명서 표와 C/asm 최적화 가이드 참조).
x86 x86 :[u]int8_t요는 .[u]int16_t임시변통의(로드/스토어에서/로[u]int16_t메모리는 괜찮지만 레지스터의 16비트 값을 사용하면 인텔 CPU의 피연산자 크기 접두사 디코딩 속도가 느려지기 때문에 큰 문제가 있습니다. 배열 인덱스로 사용하려면 32비트 임시가 더 빠릅니다. (8비트 레지스터를 사용해도 높은 24/56비트가 0이 되지 않으므로, 8비트 레지스터를 사용하려면 0이나 부호 확장 명령이 추가로 필요합니다.)ter를 배열 인덱스로 사용하거나 더 넓은 유형의 식으로 사용합니다(예: 에 추가).int.)
단일 바이트 로드에서 효율적인 영/부호 확장이나 단일 바이트 스토어에서 ARM이나 다른 아키텍처가 할 수 있는 일이 무엇인지 확신할 수 없습니다.
이런 점을 감안하여, 제가 추천하는 것은 보관용 팩, 임시용 팩입니다. (또는long에서 코드 a, 은 x86-64 에서입니다 때문입니다. 왜냐하면,REX64비트 피연산자 크기를 지정하려면 접두사가 필요합니다.) 예를 들어,
int a_i = foo[i].a;
int b_i = foo[i].b;
...;
foo[i].a = a_i + b_i;
비트 필드
비트 필드에 패킹하면 오버헤드가 더 많이 발생하지만 그래도 가치가 있을 수 있습니다.바이트 또는 32/64비트 메모리 청크에서 컴파일-시간-정수-비트 위치(또는 여러 비트)를 테스트하는 것은 빠릅니다.ints를 비 inline 기능 호출 같은 것에 전달하면 시프트 및 마스킹에 대한 몇 가지 지침이 추가로 필요합니다.이를 통해 캐시 미스를 조금이라도 줄일 수 있다면 가치가 있습니다.
또는 또는 것은 , (1로) (0으로) 를 통해 할 수 .OR아니면AND, 그러나 알 수 없는 부울 값을 비트 필드에 할당하려면 다른 필드의 비트와 새 비트를 병합하는 데 더 많은 명령이 필요합니다.비트 필드에 변수를 매우 자주 할당하면 코드가 크게 부풀 수 있습니다.그래서 사용.int foo:6foo상위 두 비트가 필요하지 않아 도움이 되지 않을 것 같습니다.각 항목을 자체 바이트/short/int에 저장하는 것에 비해 많은 비트를 절약하지 못하는 경우, 캐시 미스 감소가 추가 명령을 초과하지는 않습니다(I-cache/uop-cache 미스뿐만 아니라 명령의 직접적인 추가 지연 시간 및 작업으로 이어질 수 있음).
x86 BMI1 / BMI2(비트 조작) 명령 세트 확장을 사용하면 레지스터의 데이터를 일부 대상 비트로 복사하는 것이 더 효율적입니다(주변 비트를 흐리지 않고).BMI1: Haswell, Piledriver.BMI2: 하스웰, 굴삭기(미공개).SSE/AVX와 마찬가지로 BMI 버전의 기능이 필요하며, 이러한 지침을 지원하지 않는 CPU의 경우 BMI 버전이 필요합니다.AFAIK, 컴파일러는 이러한 명령어의 패턴을 보고 자동으로 사용할 수 있는 옵션이 없습니다.그것들은 고유한 것(또는 asm)을 통해서만 사용할 수 있습니다.
필드를 어떻게 사용하느냐에 따라 비트 필드에 패킹하는 것이 아마도 좋은 선택일 것입니다.네 번째 옵션(4개를 별도로 포장)abcd하나의 구조로 된 값)은 네 개의 순차적인 것으로 유용한 것을 할 수 없다면 아마도 실수일 것입니다.abcd값(vector 스타일).
일반적으로 코드를 지정합니다. 두 가지 방법을 모두 사용해 보십시오.
코드가 광범위하게 사용하는 데이터 구조의 경우 한 구현에서 다른 구현으로 전환하고 벤치마크할 수 있도록 설정하는 것이 합리적입니다.니르 프리드먼의 대답은 게터/세터와 함께 하는 것이 좋은 방법입니다.하지만 사용하는 것만으로도int구조물의 개별 부재로서 임시 작업 및 현장 작업이 잘 되어야 합니다.비트 필드에 대한 바이트의 올바른 비트를 테스트하기 위한 코드를 생성하는 것은 컴파일러의 몫입니다.
필요한 경우 SIMD 준비
각 구조의 한 개 또는 두 개의 필드만 확인하는 코드가 있는 경우(특히 순차 구조 값에 대한 루프), cmaster가 제공하는 배열 구조 답변이 유용할 것입니다.x86 벡터 명령어는 단일 바이트를 가장 작은 입도로 가지고 있으므로, 각각의 값을 별도의 바이트에 가지는 arrays 구조를 사용하면 다음과 같은 첫 번째 요소를 빠르게 스캔할 수 있습니다.a == something, 를 합니다.PCMPEQB / PTEST.
첫째, "가장 효율적"이라는 의미를 정확하게 정의합니다.최고의 메모리 활용률?최고의 퍼포먼스?
그런 다음 알고리즘을 두 가지 방식으로 구현하고 실제로 실행하려는 실제 하드웨어에서 실제로 프로파일링합니다.
"가장 효율적인"이라는 원래 정의에 더 적합한 것을 고르십시오.
다른 건 그저 추측일 뿐입니다.어떤 것을 선택하든 잘 작동할 것입니다. 하지만 소프트웨어를 사용하는 정확한 조건에서 실제로 차이를 측정하지 않으면 어떤 구현이 "더 효율적"인지 알 수 없습니다.
제 생각에 유일한 진짜 답은 코드를 일반적으로 작성한 다음 전체 프로그램을 모두 프로파일링하는 것입니다.조금 더 어색하게 보일 수도 있지만, 그렇게 많은 시간이 걸리지는 않을 것 같습니다.기본적으로 저는 다음과 같은 일을 합니다.
template <bool is_packed> class Foo;
using interface_int = char;
template <>
class Foo<true> {
char m_a, m_b, m_c, m_d;
public:
void setA(interface_int a) { m_a = a; }
interface_int getA() { return m_a; }
...
}
template <>
class Foo<false> {
char m_data;
public:
void setA(interface_int a) { // bit magic changes m_data; }
interface_int getA() { // bit magic gets a from m_data; }
}
원시 데이터를 노출하지 않고 코드만 이렇게 작성하면 구현 및 프로파일을 쉽게 전환할 수 있습니다.함수 호출은 인라인이 되어 성능에 영향을 주지 않습니다.참고로 저는 참조를 반환하는 함수 대신에 setA와 getA를 작성했을 뿐인데, 구현하기가 더 복잡합니다.
는 으로 지정합니다.ints
을 로 ints.
blah.x당신의 모든 코드에서, 선언이 당신이 할 모든 것이 될 것이라는 것을 제외하고.대부분의 경우를 통합 프로모션이 처리할 것입니다.
3 를 다음을 사용하는 포함 파일입니다.int는 s를 합니다.char하나는 비트필드를 사용합니다.
그리고 프로파일.이 단계에서는 너무 이른 최적화이므로 걱정하지 마십시오. 선택한 포함 파일 외에는 변경되지 않습니다.
대용량 어레이 및 메모리 부족 오류
- 전체 프로그램은 엄청난 수의 푸들로 구성되어 있습니다.
우선 #2의 경우, 기가바이트에 걸쳐 있는 경우 자신이나 사용자(다른 사용자가 소프트웨어를 실행하는 경우)가 이 어레이를 성공적으로 할당할 수 없는 경우가 많습니다.여기서 일반적인 실수는 메모리 오류가 "더 이상 사용할 수 없는 메모리"를 의미한다고 생각하는 것입니다. 대신 OS가 요청된 메모리 크기와 일치하는 사용되지 않는 페이지의 연속 집합을 찾을 수 없다는 것을 의미합니다.이러한 이유로 인해 사람들은 30기가바이트의 물리적 메모리가 있음에도 불구하고 1기가바이트 블록만 할당해 달라고 요청할 때 종종 혼란을 겪습니다. 예를 들어, 사용 가능한 일반적인 메모리 용량의 1% 이상의 크기로 메모리를 할당하기 시작하면,전체를 대표하기 위해 하나의 거대한 배열을 피하는 것을 고려해야 할 때가 많습니다.
따라서 가장 먼저 해야 할 일은 데이터 구조를 다시 생각해 보는 것입니다.단일 어레이에 수십억 개의 요소를 할당하는 대신 더 작은 청크(더 작은 어레이를 함께 집계)에 할당함으로써 문제가 발생할 확률을 크게 줄일 수 있습니다.예를 들어, 액세스 패턴이 본질적으로 순차적인 경우, 롤오버되지 않은 목록(함께 연결된 배열)을 사용할 수 있습니다.랜덤 액세스가 필요한 경우에는 각각 4 킬로바이트에 이르는 배열에 대한 포인터 배열과 같은 것을 사용할 수 있습니다.이를 위해서는 요소를 색인화하는 작업이 조금 더 필요하지만, 이와 같은 규모의 수십억 개의 요소를 사용하려면 종종 필요합니다.
액세스 패턴
질문에 명시되지 않은 것 중 하나는 메모리 액세스 패턴입니다.이 부분은 결정을 내리는 데 매우 중요합니다.
예를 들어, 데이터 구조는 순차적으로만 이동합니까, 아니면 랜덤 액세스가 필요합니까?까입니까?a,b,c,d항상 한 에 한 개두 개 세 개에 할 수 , 합니다. 아니면 한 번에 한 개 또는 두 개 또는 세 개에 액세스할 수 있습니까?
가능한 모든 가능성을 다루도록 합시다.지금 얘기하고 있는 규모로 보면, 다음과 같습니다.
struct Foo {
int a1;
int b1;
int c1;
int d1
};
... 도움이 되지 않을 것 같습니다.이러한 종류의 입력 규모와 촘촘한 루프에서 액세스할 경우 일반적으로 상위 수준의 메모리 계층(페이징 및 CPU 캐시)이 시간을 지배하게 됩니다.계층의 가장 낮은 수준(레지스터 및 관련 지침)에 초점을 맞추는 것은 더 이상 중요하지 않습니다.즉, 수십억 개의 요소를 처리해야 하는 상황에서 이 메모리를 L1 캐시 라인에서 레지스터로 이동하는 비용과 비트 단위의 명령어(예를 들어 전혀 문제가 되지 않는다고 말하는 것이 아니라 훨씬 낮은 우선 순위라고 말하는 것)에 대한 비용은 전혀 걱정할 필요가 없습니다.
핫 데이터 전체가 CPU 캐시에 들어갈 수 있는 충분히 작은 규모와 랜덤 액세스가 필요한 경우, 계층 구조의 가장 낮은 수준(레지스터 및 지시사항)에서 향상된 성능을 보여줄 수 있습니다.하지만 지금 얘기하는 것보다 훨씬 작은 규모의 정보가 필요할 겁니다.
따라서 이마저도 상당한 개선이 될 가능성이 높습니다.
struct Foo {
char a1;
char b1;
char c1;
char d1;
};
... 그리고 이것은 더욱더:
// Each field packs 4 values with 2-bits each.
struct Foo {
char a4;
char b4;
char c4;
char d4;
};
* 위의 경우 비트 필드를 사용할 수 있지만 비트 필드는 사용되는 컴파일러에 따라 관련된 주의 사항이 있는 경향이 있습니다. 일반적으로 설명되는 휴대성 문제로 인해 이러한 문제를 피하기 위해 종종 주의를 기울였지만, 고객님의 경우에는 불필요할 수도 있습니다. 그러나 SoA와 아래의 핫/콜드 필드 분할 영역을 모험하면서 비트필드를 사용할 수 없는 지점에 도달할 것입니다.
이 코드는 수평 논리에 초점을 맞추어 이미 소형 SoA 형태로 되어 있기 때문에 몇 가지 추가 최적화 경로(예: SIMD를 사용하도록 코드 변환)를 쉽게 탐색할 수 있습니다.
데이터 "소비"
특히 이런 규모로, 메모리 액세스가 순차적으로 이루어지는 경우에는 데이터 "소비" 측면에서 생각하는 데 도움이 됩니다(기계가 얼마나 빨리 데이터를 로드하고 필요한 연산을 수행하고 결과를 저장할 수 있는지).내가 유용하다고 생각하는 간단한 정신 이미지는 컴퓨터가 "입이 큰" 것으로 상상하는 것입니다.작은 티스푼이 아니라 데이터를 한 번에 충분히 스푼으로 제공하고 더 관련성 있는 데이터를 연속 스푼으로 촘촘하게 포장하면 속도가 빨라집니다.
핫/콜드 필드 분할
위 코드는 지금까지 이 모든 필드가 동일하게 핫(자주 액세스됨) 상태이며, 함께 액세스됨을 가정하고 있습니다.중요 코드 경로에서만 쌍으로 액세스되는 콜드 필드 또는 필드가 있을 수 있습니다.당신이 거의 접근할 수 없다고 가정해 보겠습니다.c그리고.d가 있는지 , a그리고.b 것, c그리고.d에는 다음과 같은 두 구조로 보는 이 될 수 이 경우 다음과 같은 두 가지 구조로 나누어 보는 것이 도움이 될 수 있습니다.
struct Foo1 {
char a4;
char b4;
};
struct Foo2 {
char c4;
char d4;
};
가 컴퓨터 를 "가 "를" 요.a그리고.b재,다 한 더 양을 수 있습니다.a그리고.b필드만 포함하는 연속된 블록이 있는 경우 a그리고.bc그리고.d들녘그런 경우에는c그리고.d는 현재 수 다이지만 됩니다.a그리고.b들녘한 , 관심. 따라서 하는 것이 컴퓨터가 가능한 한 빨리 데이터를 소비하기를 원한다면, 우리는 현재 관심 있는 관련 데이터만 컴퓨터에 제공해야 합니다. 따라서 이러한 시나리오의 구조를 분할하는 것이 좋습니다.
순차 접근을 위한 SIMD SOA
벡터화로 나아가고 순차적 접근을 가정할 때, 컴퓨터가 데이터를 소비할 수 있는 가장 빠른 속도는 종종 SIMD를 사용하여 병렬로 이루어지게 됩니다. 이러한 경우, 우리는 다음과 같은 표현을 하게 될 수도 있습니다.
struct Foo1 {
char* a4n;
char* b4n;
};
... XMM/YMM 레지스터에 더 빠른 정렬 이동을 사용하기 위해 필요한 정렬 및 패딩(크기/정렬은 AVX의 경우 16바이트 또는 32바이트의 배수여야 하며 미래형 AVX-512의 경우에도 64바이트여야 함)에 세심한 주의를 기울임.
랜덤/멀티필드 액세스를 위한 AoSOA
위은 할 할 수 있습니다.a그리고.b함께 자주 액세스되며, 특히 랜덤 액세스 패턴을 사용합니다.이러한 다와 할 수 .
struct Foo1 {
char a4x32[32];
char b4x32[32];
};
이 하고 있는에서... 지금 이 구조를 집계하고 있습니다이렇게 하면 정말.a그리고.b은 더 있지 다의 을 허용합니다. 32합니다.a그리고.b단일 64바이트 캐시 라인에 적합하고 함께 신속하게 액세스할 수 있는 필드입니다.128이나 256도 맞출 수 있습니다.a아니면b요소를 XMM/YMM 레지스터에 입력합니다.
프로파일링
보통 저는 수행 질문에서 일반적인 지혜에 대한 조언을 피하려고 노력하지만, 이 질문은 프로파일러를 가지고 있는 사람이 일반적으로 언급하는 세부 사항을 피하려는 것 같습니다.그래서 이것이 약간 후견적인 것으로 비쳐지거나 프로파일러가 이미 적극적으로 사용되고 있다면 사과하지만, 저는 그 질문이 이 부분을 정당화할 수 있다고 생각합니다.
일화로 컴퓨터 아키텍처에 대해 나보다 훨씬 뛰어난 지식을 가진 사람들이 작성한 생산코드 최적화 작업을 자주 (펀치카드 시대에 와서 조립코드를 한눈에 파악할 수 있는 사람들과 작업을 많이 했음),그리고 종종 코드를 최적화하기 위해 불려가곤 했습니다 (정말 이상하게 느껴졌습니다).그것은 한 가지 간단한 이유 때문입니다. 저는 프로파일러(VTune)를 사용했습니다.제 동료들은 종종 그렇지 않았습니다(그들은 그것에 알레르기가 있고 그들이 핫스팟을 프로파일러와 마찬가지로 이해하고 프로파일링을 시간 낭비라고 생각했습니다).
물론 이상적인 것은 컴퓨터 아키텍처 전문 지식과 프로파일러를 모두 손에 쥔 사람을 찾는 것이지만, 이런 저런 것이 없으면 프로파일러는 더 큰 장점을 제공할 수 있습니다.최적화는 여전히 가장 효과적인 우선순위에 따라 결정되는 생산성 사고방식을 보상하며, 가장 효과적인 우선순위는 가장 중요한 부품을 최적화하는 것입니다.프로파일러는 정확하게 얼마나 많은 시간이 소요되고 어디에 사용되는지에 대한 세부적인 분석과 함께 캐시 미스 및 분기 예측과 같은 유용한 메트릭을 제공합니다. 이는 일반적으로 가장 고급의 인간도 프로파일러가 보여줄 수 있는 정확한 데이터를 예측할 수 없습니다.또한 프로파일링은 핫스팟을 추적하고 핫스팟이 존재하는 이유를 조사함으로써 컴퓨터 아키텍처가 보다 빠른 속도로 작동하는 방법을 알아내는 열쇠가 되기도 합니다.저에게 프로파일링은 컴퓨터 아키텍처가 실제로 어떻게 작동하는지를 더 잘 이해할 수 있는 궁극적인 시작점이지 제가 상상했던 작동 방식이 아니었습니다.은 그제서야다가 .Mysticial점점 더 말이 되기 시작했습니다.
인터페이스 디자인
여기서 분명해지기 시작할 수 있는 것 중 하나는 많은 최적화 가능성이 있다는 것입니다.이런 질문에 대한 답은 절대적인 접근보다는 전략에 관한 것이 될 것입니다.아직도 많은 것들이 무언가를 시도한 후에 나중에 다시 발견되어야 하며, 필요에 따라 점점 더 많은 최적의 해결책을 찾아내야 합니다.
여기서 복잡한 코드베이스의 어려움 중 하나는 인터페이스에 다양한 최적화 기술을 실험하고 시도할 수 있는 충분한 공간을 두고 더 빠른 솔루션을 반복하고 반복하는 것입니다.인터페이스가 이러한 최적화를 모색할 수 있는 여지를 남겨두면 하루 종일 최적화할 수 있고 시행착오를 겪더라도 제대로 측정할 경우 놀라운 결과를 얻을 수 있습니다.
더 빠른 기술을 실험하고 탐색할 수 있는 충분한 공간을 구현에 남겨두기 위해서는 종종 인터페이스 설계에서 데이터를 대량으로 수용해야 합니다.인터페이스에 간접 함수 호출(예: dylib 또는 함수 포인터를 통한)이 포함된 경우에는 특히 그렇습니다. 여기서 인라인은 더 이상 효과적인 가능성이 없습니다.그러한 시나리오에서, 계단식 인터페이스 파손 없이 최적화할 수 있는 여지를 남긴다는 것은 종종 (다양한 인터리빙 가능성이 있는 경우) 전체 데이터 덩어리에 포인터를 전달하는 것을 선호하는 단순한 스칼라 매개 변수를 받는 사고방식에서 벗어나 설계한다는 것을 의미합니다.따라서 이 작업이 상당히 광범위한 영역으로 옮겨가고 있지만, 여기서 최적화를 위한 많은 최우선 과제는 코드베이스 전체에 걸쳐 변경 사항을 단계적으로 조정하지 않고 구현을 최적화할 수 있는 충분한 공간을 확보하고 올바른 방법을 안내하는 프로파일러를 보유하는 것으로 귀결될 것입니다.
TL;DR
어쨌든, 이러한 전략 중 일부는 올바른 길을 안내하는 데 도움이 될 것입니다.여기에는 절대적인 것은 없고 가이드와 시도해 볼 것만 있으며 항상 프로파일러를 손에 들고 하는 것이 가장 좋습니다.하지만 이렇게 방대한 규모의 데이터를 처리할 때는 항상 배고픈 괴물의 이미지를 기억해야 하며, 이와 같이 적절한 크기의 포장된 관련 데이터를 가장 효과적으로 공급하는 방법을 기억해야 합니다.
예를 들어, 좀 더 오래된 메모리 버스가 있고 10GB/s를 전송할 수 있습니다.이제 2.5GHz의 CPU를 사용하면 메모리 버스를 포화시키기 위해 사이클당 최소 4바이트를 처리해야 한다는 것을 알 수 있습니다.이와 같이, 다음의 정의를 사용할 때
struct Foo {
char a;
char b;
char c;
char d;
}
데이터를 통과할 때마다 4개의 변수를 모두 사용하면 코드가 CPU 바인딩됩니다.밀도 높은 포장으로는 속도를 낼 수 없습니다.
이제 각 패스가 네 개의 값 중 하나에 대해 사소한 연산만 수행할 때 이는 달라집니다.이 경우에는 다음과 같은 구조의 어레이를 사용하는 것이 더 좋습니다.
struct Foo {
size_t count;
char* a; //a[count]
char* b; //b[count]
char* c; //c[count]
char* d; //d[count]
}
당신은 C/C++ 태그의 공통적이고 모호한 내용을 말씀하셨습니다.
C++를 가정하면 데이터를 비공개로 만들고 getter/setter를 추가합니다.아니요, 옵티마이저가 켜져 있으면 성능 히트가 발생하지 않습니다.
그런 다음 구현을 변경하여 호출 코드를 변경하지 않고 대안을 사용할 수 있으므로 벤치 테스트 결과에 따라 구현을 보다 쉽게 조정할 수 있습니다.
공식적으로 말씀드리면, 제가 예상하는 것은struct@dbush에 따라 비트 필드를 지정하면 설명이 가장 빠를 가능성이 높습니다.
이 모든 것은 데이터를 캐시에 보관하는 것과 관련된 것입니다. 호출 알고리즘의 설계가 이러한 작업에 도움이 되는지도 확인하고 싶을 수도 있습니다.
질문에 대한 답을 다시 시작합니다.
타이트 루프에 사용됨;
그들의 값은 초당 10억 번 읽히며, 그것이 프로그램의 병목 현상입니다.
전체 프로그램은 엄청난 수의 푸들로 구성되어 있습니다.
각 구현 플랫폼에 대해 설계하는 데 시간이 걸리지만 이점이 비용을 초과하는 플랫폼별 고성능 코드를 작성해야 하는 경우의 전형적인 예입니다.
전체 프로그램의 병목 현상이기 때문에 일반적인 솔루션을 찾는 것은 아니지만, 실제 데이터를 기준으로 여러 가지 접근 방식을 테스트하고 시간을 조정해야 합니다. 최상의 솔루션은 플랫폼에 따라 다릅니다.
또한 수십억 개의 푸들의 대규모 배열이기 때문에 OP가 OpenCL 또는 OpenMP를 잠재적인 해결책으로 사용하여 런타임 하드웨어에서 사용 가능한 리소스를 최대한 활용하는 것을 고려해야 할 수도 있습니다.이는 데이터에서 필요로 하는 것에 약간 의존하지만, 이러한 유형의 문제 중 가장 중요한 측면인 가용 병렬성을 활용하는 방법일 것입니다.
하지만 이 질문에 대한 정답은 하나도 없습니다, IMO.
가장 효율적인 성능/실행은 프로세서의 워드 크기를 사용하는 것입니다.프로세서로 하여금 포장이나 포장을 추가로 수행하게 하지 마십시오.
효율적인 크기가 두 개 이상인 프로세서도 있습니다.많은 ARM 프로세서는 8/32비트 모드로 작동할 수 있습니다.이는 프로세서가 8비트 또는 32비트를 처리하는 데 최적화되어 있음을 의미합니다.이런 프로세서라면 8비트 데이터 타입을 사용하는 것이 좋습니다.
당신의 알고리즘은 효율성과 많은 관련이 있습니다.데이터를 이동하거나 데이터를 복사하는 경우 데이터를 한 번에 32비트씩 이동하는 것을 고려할 수 있습니다(48비트 양).여기서의 아이디어는 프로세서에 의한 페치 수를 줄이는 것입니다.
성능을 위해 더 많은 로컬 변수를 사용하는 등 레지스터를 사용하기 위해 코드를 작성합니다.메모리에서 레지스터로 가져오는 것은 레지스터를 직접 사용하는 것보다 비용이 더 많이 듭니다.
가장 좋은 것은 컴파일러 최적화 설정을 확인하는 것입니다.최고 성능(속도) 설정을 위해 컴파일을 설정합니다.다음으로 함수의 어셈블리 언어 목록을 생성합니다.목록을 검토하여 컴파일러가 코드를 생성한 방법을 확인합니다.컴파일러의 최적화 기능을 향상시키기 위해 코드를 조정합니다.
이라면, 를 것을 .struct모두 합하여그 16바이트 일 수 로 만들 입니다.컴파일러는 필요에 따라 구조 표현에 패딩을 삽입하여 그 크기를 정렬 요구사항의 배수(최대 16바이트 또는 8바이트일 가능성이 높음)로 만들 것입니다.
구조체를 사용하는 경우 구현에 따라 사용할 구조체가 달라집니다.만약 @dbush의 비트필드 접근 방식이 1바이트 구조를 산출한다면, 그것을 이기기는 어렵습니다.그러나 어떠한 경우에도 표현을 최소 4바이트로 패딩하려면 다음과 같은 방법을 사용해야 합니다.
struct Foo {
char a;
char b;
char c;
char d;
};
아니면 아마 이 변형을 사용할 것 같습니다.
struct Foo {
uint8_t a;
uint8_t b;
uint8_t c;
uint8_t d;
};
구조물이 최소 4바이트를 차지한다고 가정하기 때문에 데이터를 더 작은 공간으로 포장하는 것은 의미가 없습니다.사실, 이는 프로세서로 하여금 추가적인 작업 포장과 내부 가치 포장 해제 작업을 수행하게 만들기 때문에 생산성에 반할 수 있습니다.
많은 양의 데이터를 처리하는 데 있어 CPU 캐시를 효율적으로 사용하면 몇 가지 정수 작업을 피하는 것보다 훨씬 큰 이점을 얻을 수 있습니다.데이터 사용 패턴이 적어도 어느 정도 체계적이라면(예: 구조 배열의 한 요소에 액세스한 후 다음에 인접한 요소에 액세스할 가능성이 있는 경우) 데이터를 최대한 꽉 채워 공간 효율성과 속도를 모두 높일 수 있습니다.C 구현(또는 구현 종속성을 방지하려는 경우)에 따라 정수 배열을 통해 이를 다르게 달성해야 할 수도 있습니다.각를각 2한 4해로 을 고려해 . 조"입니다를각합니다.uint8_t대신에, 각각 총 1바이트의 경우.
아마 이런 거겠지.
#include <stdint.h>
#define NUMBER_OF_FOOS 1000000000
#define A 0
#define B 2
#define C 4
#define D 6
#define SET_FOO_FIELD(foos, index, field, value) \
((foos)[index] = (((foos)[index] & ~(3 << (field))) | (((value) & 3) << (field))))
#define GET_FOO_FIELD(foos, index, field) (((foos)[index] >> (field)) & 3)
typedef uint8_t foo;
foo all_the_foos[NUMBER_OF_FOOS];
필드 이름 매크로와 액세스 매크로는 배열을 직접 조작하는 것보다 개별 필드에 액세스할 수 있는 더 읽기 쉽고 조정 가능한 방법을 제공합니다(그러나 특정 매크로는 자신의 인수 중 일부를 두 번 이상 평가합니다).모든 비트를 사용하므로 데이터 구조만 선택하면 가능한 한 좋은 캐시 사용률을 얻을 수 있습니다.
잠시 비디오 압축 풀기를 했습니다.가장 빠른 작업은 다음과 같습니다.
short ABCD; //use a 16 bit data type for your example
매크로를 설정합니다.아마도:
#define GETA ((ABCD >> 12) & 0x000F)
#define GETB ((ABCD >> 8) & 0x000F)
#define GETC ((ABCD >> 4) & 0x000F)
#define GETD (ABCD & 0x000F) // no need to shift D
대부분의 최신 프로세서에서 기본 MOVE 크기이기 때문에 실제로는 32비트 길이 또는 64비트 길이로 이동을 시도해야 합니다.
struct를 사용하면 struct의 기본 주소에서 필드까지 컴파일된 추가 명령 코드에 오버헤드가 항상 생성됩니다.그러니 정말로 고리를 조이고 싶다면 거기서 벗어나세요.
편집: 위의 예제는 4비트 값을 제공합니다.만약 당신이 정말로 0의 값이 필요하다면..3 그러면 동일한 작업을 수행하여 2비트 숫자를 추출할 수 있으므로, GETA는 다음과 같습니다.
GETA ((ABCD >> 14) & 0x0003)
그리고 만약 여러분이 정말로 수십억개의 것들을 움직이고 있고, 제가 의심하지 않는다면, 그냥 32비트 변수를 채우고 그것을 통해 이동하고 가면 됩니다.
도움이 되길 바랍니다.
언급URL : https://stackoverflow.com/questions/31731684/what-is-the-most-efficient-way-to-represent-small-values-in-a-struct
'codememo' 카테고리의 다른 글
| is java.sql.타임스탬프 시간대를 지정하시겠습니까? (0) | 2023.09.25 |
|---|---|
| 시작 작업의 매개 변수 중 하나로 스크립트 블록을 전달하려면 어떻게 해야 합니까? (0) | 2023.09.25 |
| ajax를 통해 폼을 게시하고 playframework java에서 폼 오브젝트를 가져옵니다. (0) | 2023.09.25 |
| jQuery 플러그인 구문을 이해하고 싶습니다. (0) | 2023.09.25 |
| iOS 앱에서 L2TP 프로토콜로 VPN 구현 (0) | 2023.09.25 |