KR20130111167A - 정보 처리 장치, 연산 장치 및 정보 전송 방법 - Google Patents

Abstract

노드의 고장이 발생했을 때에 다른 노드에 고장이 전파되지 않도록 한다.
노드(10 내지 10m)는 노드(10 내지 10m) 사이에서 송수신하는 데이터를 메모리에 저장할 때의 어드레스를 나타내는 라이트 포인터와, 데이터를 메모리로부터 판독할 때의 어드레스를 나타내는 리드 포인터를 대응시킨 복수 개의 포인터 세트를 기억한다. 또한, 노드(10 내지 10m)는, 포인터 세트를 나타내는 포인터 식별자를 데이터의 송신원이 되는 노드에 통지한다. 또한, 노드(10 내지 10m)는 데이터의 송신처가 되는 노드로부터 포인터 식별자의 통지를 접수한 경우에는, 포인터 식별자를 데이터와 함께 송신한다. 그리고, 노드(10 내지 10m)는 데이터의 송신원이 되는 노드로부터 포인터 식별자와 데이터를 수신한 경우에는, 포인터 식별자가 나타내는 포인터 세트의 라이트 포인터가 나타내는 어드레스에 따라 수신한 데이터를 메모리에 저장한다.

Description

정보 처리 장치, 연산 장치 및 정보 전송 방법{INFORMATION PROCESSING APPARATUS, ARITHMETIC DEVICE, AND INFORMATION TRANSFERRING METHOD}

본 발명은 정보 처리 장치, 연산 장치 및 정보 전송 방법에 관한 것이다.

종래, 복수 개의 소프트웨어가 연계하여 처리를 실행할 때에, 각 소프트웨어가 사용하는 데이터를 송수신하는 프로세스간 통신(IPC: Inter Process Communication)의 기술이 알려져 있다. 이러한 프로세스간 통신을 수행하는 기술의 일례로서, 큐를 이용하여 프로세스간 통신을 수행하는 기술이 알려져 있다.

이하, 도 40 내지 도 43을 이용하여 큐를 이용하여 프로세스간 통신을 수행하는 기술의 일례에 대해 설명한다. 도 40은 종래의 소프트웨어에 의한 프로세스간 통신의 개념을 설명하기 위한 도면이다. 예컨대, 도 40에 도시한 예에서는, 각 사용자 프로세스 A 내지 C는 사용자 프로세스 D에 대해 송신하는 데이터를 소프트웨어에 의해 실현된 FIFO(First In First Out) 방식의 큐에 저장한다. 한편, 사용자 프로세스 D는 FIFO 방식의 큐에 저장된 데이터를 선두부터 순서대로 취득한다.

다음, 도 41을 이용하여, 사용자 프로세스 A 내지 C가 큐를 이용하여 사용자 프로세스 D에 메시지 A 내지 C의 송신을 수행할 때에 실행하는 처리의 내용에 대해 설명한다. 도 41은 종래의 소프트웨어에 의한 프로세스간 통신에서의 처리를 설명하기 위한 도면이다. 도 41에 도시한 예에서는, 큐로서 사용되는 기억 영역의 베이스 어드레스, 데이터의 판독 어드레스를 나타내는 리드 포인터 및 데이터의 기입 어드레스를 나타내는 라이트 포인터가 메모리에 저장된다. 또한, 이하의 예에서는 초기 상태의 리드 포인터와 라이트 포인터의 값은 "0x0120"인 것으로 한다.

예컨대, 사용자 프로세스 A는, 라이트 포인터를 참조하여 라이트 포인터가 나타내는 어드레스 "0x0120"로부터 32바이트의 메시지 A를 저장한다. 그리고, 사용자 프로세스 A는 라이트 포인터의 값 "0x0120"에 "0x0020"을 가산하고, "0x0140"으로 갱신한다. 또한, 사용자 프로세스 A는 라이트 포인터의 갱신을 수행하는 경우에는 CAS(Compare And Swap) 명령이나 FAD(Fetch And Add) 명령 등의 아토믹한(Atomic) 명령을 발행하거나, 라이트 포인터의 배타적 록(exclusive lock)을 취득하는 등의 배타 제어를 수행한다.

계속해서, 사용자 프로세스 B는 사용자 프로세스 A와 동일하게, 라이트 포인터를 참조하여 라이트 포인터가 나타내는 어드레스 "0x0140"로부터 32바이트의 메시지 B를 저장하고, 라이트 포인터의 값을 "0x0140"에서 "0x0160"으로 갱신한다. 또한, 사용자 프로세스 C도 마찬가지로 라이트 포인터가 나타내는 어드레스 "0x0160"에 메시지 C를 저장하고, 라이트 포인터의 값을 "0x0160"에서 "0x0180"으로 갱신한다.

한편, 사용자 프로세스 D는 사용자 프로세스 A 내지 C와 비동기로 리드 포인터의 값과 라이트 포인터의 값이 일치하는지 여부를 판별하고, 각 값이 일치하지 않는 경우에는 새로운 메시지가 큐에 저장되어 있다고 판별한다. 그리고, 사용자 프로세스 D는 새로운 메시지가 큐에 저장된다고 판별한 경우에는, 리드 포인터가 나타내는 어드레스로부터 메시지의 판독을 수행한다.

예컨대, 사용자 프로세스 D는 리드 포인터의 값이 "0x0120"이고, 라이트 포인터의 값이 "0x0160"이기 때문에, "0x0120"로부터 메시지 A를 판독하고, 리드 포인터의 값을 "0x0120"에서 "0x0140"으로 갱신한다. 이러한 처리를 리드 포인터와 라이트 포인터의 값이 일치할 때까지 반복함으로써, 사용자 프로세스 D는 큐에 저장된 각 메시지 A 내지 C의 판독을 수행한다.

여기서, 복수 개의 CPU가 각각 상이한 프로세스를 실행하는 멀티노드 시스템의 기술이 알려져 있다. 이러한 멀티노드 시스템의 기술의 일례로서, 데이터를 캐시하는 기능을 갖는 CPU(Central Processing Unit)를 복수 개 가지며, 각 CPU가 각각 상이한 프로세스를 동시에 실행하는 정보 처리 시스템이 알려져 있다. 나아가서는, 각 CPU가 각각 독립된 OS를 실행하고, 이 CPU 사이에서 일부의 메모리 영역을 공유하는 공유 메모리 시스템의 기술이 알려져 있다. 이러한 구성으로 함으로써, 처리 능력을 보다 향상시킬 수 있고, 나아가 각 노드에서 OS가 개별적으로 동작함으로써, 에러의 파급을 방지할 수 있으므로 시스템의 가용성을 향상시킬 수 있다.

도 42는 공유 메모리를 사용한 멀티노드 시스템의 개념을 설명하기 위한 도면이다. 도 42에 도시한 바와 같이, 정보 처리 시스템은 각각 개별적인 CPU #0 내지 #3를 갖는 복수 개의 노드 #0 내지 #3를 갖는다. 또한 각 노드 #0 내지 #3는, 로컬 메모리, HPV(Hypervisor) 소프트웨어, OS(Operating System), 디바이스 드라이버를 가지며, 각각 상이한 사용자 프로세스 A 내지 D를 동시에 실행한다. 또한, HPV 소프트웨어란, 각 노드 #0 내지 #3가 가동시키는 가상 머신의 관리를 수행하는 소프트웨어이다. 이러한 정보 처리 시스템에서는, 각 노드 #0 내지 #3이 공유하는 공유 메모리에 라이트 포인터와 리드 포인터를 저장함으로써 큐를 실현하고, 사용자 프로세스 A 내지 D 사이의 프로세스간 통신을 수행한다.

이하, 도 43을 이용하여 사용자 프로세스 A 내지 C가 사용자 프로세스 D에 메시지 A 내지 C를 송신할 때에 각 CPU #0 내지 #3이 실행하는 처리의 일례에 대해 설명한다. 도 43은 각 노드가 라이트 포인터를 캐시하는 처리를 설명하기 위한 도면이다. 예컨대, 사용자 프로세스 A를 실행하는 CPU #0은, 공유 메모리 상의 라이트 포인터를 캐시하고, 라이트 포인터가 나타내는 어드레스 "0x0120"로부터 메시지 A를 저장한다(도 43 중 (1)). 또한, CPU #0은 캐시한 라이트 포인터의 값을 "0x0140"으로 갱신하고(도 43 중 (2)), 라이트 포인터의 캐시 라인이 갱신 스테이트(소위 Modify)인 취지를 기억한다.

계속해서, 사용자 프로세스 B를 실행하는 CPU #1은, 라이트 포인터의 캐시 라인이 갱신 스테이트이기 때문에, CPU #0이 갱신한 라이트 포인터를 CPU #0으로부터 캐시한다(도 43 중 (3)). 그리고, CPU #1은, 캐시한 라이트 포인터가 나타내는 어드레스 "0x0140"으로부터 메시지 B를 저장하면, 라이트 포인터의 값을 "0x0160"으로 갱신한다(도 43 중 (4)). 마찬가지로, 사용자 프로세스 C를 실행하는 CPU #2는, CPU #1이 갱신한 라이트 포인터를 CPU #1로부터 캐시하고(도 43 중 (5)), 캐시한 라이트 포인터가 나타내는 어드레스 "0x0160"으로부터 메시지 C를 저장한다. 그리고, CPU #2는 라이트 포인터의 값을 "0x0180"으로 갱신한다(도 43 중 (6)).

여기서, 사용자 프로세스 D를 실행하는 CPU #3은 리드 포인터를 공유 메모리로부터 캐시한다(도 43 중 (7)). 또한, CPU #3은, 라이트 포인터의 캐시 라인이 갱신 스테이트이기 때문에 CPU #2가 갱신한 라이트 포인터를 CPU #2로부터 캐시한다(도 43 중 (8)). 그러면, CPU #3은, 리드 포인터의 값 "0x0120"과 라이트 포인터의 값 "0x0160"이 일치하지 않으므로, 리드 포인터가 나타내는 어드레스로부터 메시지를 판독하고, 리드 포인터의 값을 갱신한다. 그 후, CPU #3은, 리드 포인터의 값과 라이트 포인터의 값이 일치할 때까지, 메시지의 판독과 리드 포인터의 갱신을 수행하고, 각 프로세스 A 내지 C가 송신한 메시지 A 내지 C를 취득한다.

특허 문헌 1: 일본 특허 제2703417호 공보 특허 문헌 2: 일본 특허 공개 2003-216592호 공보 특허 문헌 3: 일본 특허 공개 평 07-200506호 공보

그러나, 공유 메모리 상에 리드 포인터와 라이트 포인터를 저장하는 기술에서는, 데이터 송신측의 노드가 라이트 포인터를 캐시하고, 캐시한 라이트 포인터의 값을 갱신한다. 따라서, 라이트 포인터를 캐시한 노드가 고장난 경우에는, 다른 노드가 라이트 포인터의 최신의 값을 취득할 수 없기 때문에, 데이터의 전송을 수행할 수 없게 된다. 이 결과, 다른 노드에 고장이 전파된다는 문제가 있다.

이하, 도 44를 이용하여, 라이트 포인터를 캐시하고 있는 노드가 고장났을 때에, 다른 노드에 고장이 전파된다는 문제에 대해 설명한다. 도 44는, 노드가 고장났을 때에 다른 노드에 고장이 전파되는 흐름을 설명하기 위한 도면이다.

예컨대, CPU #0은 공유 메모리 상의 라이트 포인터를 캐시하고, 메시지 A를 저장하고, 캐시한 라이트 포인터의 값을 "0x0140"으로 갱신한다. 계속해서, CPU #1은 CPU #0이 갱신한 라이트 포인터를 CPU #0으로부터 캐시하면, 캐시한 라이트 포인터가 나타내는 어드레스 "0x0140"으로부터 메시지 B를 저장하고, 라이트 포인터의 값을 "0x0160"으로 갱신한다.

여기서, 노드 #1에 있어서 에러가 발생하고, CPU #1이 이상 정지했다고 하자. 그러면, CPU #2는, 메시지를 송신하기 위해 CPU #1이 갱신한 라이트 포인터를 캐시하려고 하는데, CPU #1이 정지되어 있으므로 도 44 중 (A)에 도시한 바와 같이 라이트 포인터를 캐시할 수 없다. 따라서, CPU #2는 처리를 계속할 수 없어 이상 정지해 버린다.

또한, CPU #3은, 새로운 메시지가 송신되었는지 여부를 판별하기 위해, 라이트 포인터를 캐시하려고 한다. 그러나, CPU #3은 CPU #1이 정지되어 있으므로, 도 44 중 (B)에 도시한 바와 같이, CPU #1로부터 라이트 포인터를 캐시할 수 없어, 이상 정지해 버린다. 나아가, CPU #0은, CPU #3이 이상 정지한 경우에는 메시지 A에서 지정한 처리가 실행되지 않기 때문에, 타임 아웃 등에 의해 이상 정지할 가능성이 있다.

하나의 측면에서는, 본 발명은 멀티노드 시스템의 기술이 적용된 프로세스간 통신에 있어서, 노드의 고장이 발생했을 때에 다른 노드에 고장이 전파되지 않도록 하는 것을 목적으로 한다.

하나의 측면에서는, 각각이 프로세서 및 기억 장치를 구비하는 복수 개의 노드를 갖는 정보 처리 장치이다. 여기서, 노드는, 노드 사이에서 송수신하는 데이터를 기억 장치에 저장할 때의 어드레스를 나타내는 라이트 포인터와, 데이터를 기억 장치로부터 판독할 때의 어드레스를 나타내는 리드 포인터를 대응시킨 복수 개의 포인터 세트를 기억한다. 그리고, 노드는, 포인터 세트를 나타내는 포인터 식별자를 데이터의 송신원이 되는 노드에 통지한다. 그리고, 노드는, 데이터의 송신원이 되는 노드로부터 데이터와 함께, 데이터의 송신원이 되는 노드에 통지한 포인터 식별자를 수신한 경우에는, 포인터 식별자가 나타내는 포인터 세트의 라이트 포인터가 나타내는 어드레스에 따라, 수신한 데이터를 저장한다.

일 실시 형태에서는 멀티플 노드 시스템의 기술이 적용된 프로세스간 통신에 있어서, 노드의 고장이 발생했을 때에 다른 노드에 고장이 전파되지 않도록 한다.

도 1은 실시예 1에 따른 정보 처리 시스템을 설명하기 위한 도면이다.
도 2는 실시예 1에 따른 노드의 기능 구성을 설명하기 위한 도면이다.
도 3은 실시예 1에 따른 메모리의 할당을 설명하기 위한 도면이다.
도 4는 실시예 1에 따른 정보 처리 시스템이 각 메모리에 매핑하는 메모리 맵을 설명하기 위한 도면이다.
도 5는 실시예 1에 따른 정보 처리 시스템에 있어서, 하드웨어와 소프트웨어와의 관계를 설명하기 위한 도면이다.
도 6은 실시예 1에 따른 CPU가 실행하는 처리의 개념을 설명하기 위한 도면이다.
도 7은 실시예 1에 따른 프로세스간 통신의 처리의 흐름을 설명하기 위한 도면이다.
도 8은 실시예 1에 따른 CPU의 기능 구성을 설명하기 위한 도면이다.
도 9는 실시예 1에 따른 송신 제어부의 기능 구성을 설명하기 위한 도면이다.
도 10은 각 레지스터에 부여되는 어드레스의 일례를 설명하기 위한 도면이다.
도 11은 MSGQ-ID의 포맷의 일례를 설명하기 위한 도면이다.
도 12는 MSGQ-ID의 각 필드에 저장되는 정보를 설명하기 위한 도면이다.
도 13은 패킷 포맷의 일례를 설명하기 위한 도면이다.
도 14는 응답의 패킷 포맷의 일례를 설명하기 위한 도면이다.
도 15는 실시예 1에 따른 수신 제어부의 기능 구성을 설명하기 위한 도면이다.
도 16은 RAM의 필드의 일례를 설명하기 위한 도면이다.
도 17은 RAM의 필드에 저장되는 데이터의 내용을 설명하기 위한 도면이다.
도 18은 소프트웨어에서 본 수신 제어부의 레지스터의 어드레스의 일례를 설명하기 위한 도면이다.
도 19는 메모리 라이트 어드레스의 일례를 설명하기 위한 도면이다.
도 20은 동작 종류별로 RAM의 필드의 갱신 부분을 설명하기 위한 도면이다.
도 21은 메시지 기억 영역을 설명하기 위한 도면이다.
도 22는 프로그램 미스를 고려한 어드레스 맵을 설명하기 위한 도면이다.
도 23은 프로그램 미스를 고려한 어드레스 맵에 있어서, 어드레스 구성을 설명하기 위한 도면이다.
도 24는 메시지를 송수신할 때의 동작을 설명하기 위한 시퀀스도이다.
도 25는 인터럽트 명령을 이용하여 사용자 프로세스에 도착 통지를 발행하는 처리의 흐름을 설명하기 위한 시퀀스도이다.
도 26은 송신측 노드에서 컨텍스트 스위치가 발생한 경우의 처리의 흐름을 설명하기 위한 시퀀스도이다.
도 27은 종래의 인피니밴드(InfiniBand)에 있어서, 큐 페어의 기능을 설명하기 위한 도면이다.
도 28은 프로세스 사이에서 큐 페어를 공유화했을 때의 처리를 설명하기 위한 도면이다.
도 29는 새로운 메시지 큐를 획득한 프로세스가 실행하는 처리의 흐름을 설명하기 위한 플로 차트이다.
도 30은 드라이버가 새로운 메시지 큐를 획득하는 처리의 흐름을 설명하기 위한 플로 차트이다.
도 31은 송신측의 CPU에 있어서, 메시지 송신 처리의 흐름을 설명하기 위한 플로 차트이다.
도 32는 수신측의 CPU에 있어서, 메시지 수신 처리의 흐름을 설명하기 위한 플로 차트이다.
도 33은 실시예 2에 따른 수신 제어부의 기능 구성을 설명하기 위한 도면이다.
도 34는 실시예 2에 따른 RAM의 필드의 정의를 설명하기 위한 도면이다.
도 35는 실시예 2에 따른 RAM의 필드에 저장되는 데이터의 내용을 설명하기 위한 도면이다.
도 36은 실시예 2에 따른 소프트웨어에서 본 수신 제어부의 어드레스의 일례를 설명하기 위한 도면이다.
도 37은 실시예 2에 따른 RAM의 필드를 갱신하는 처리를 설명하기 위한 도면이다.
도 38은 실시예 2에 있어서 오버플로우가 발생했을 때에 실행하는 처리의 흐름을 설명하기 위한 시퀀스도이다.
도 39는 실시예 2에 따른 CPU가 오버플로우의 발생시에 실행하는 처리의 흐름을 설명하기 위한 플로 차트이다.
도 40는 종래의 소프트웨어에 의한 프로세스간 통신의 개념을 설명하기 위한 도면이다.
도 41은 종래의 소프트웨어에 의한 프로세스간 통신에서의 처리를 설명하기 위한 도면이다.
도 42는 공유 메모리를 사용한 멀티노드 시스템의 개념을 설명하기 위한 도면이다.
도 43은 각 노드가 라이트 포인터를 캐시하는 처리를 설명하기 위한 도면이다.
도 44는 노드가 고장났을 때에 다른 노드에 고장이 전파되는 흐름을 설명하기 위한 도면이다.

이하, 첨부 도면을 참조하여 본원에 따른 정보 처리 장치, 연산 장치 및 정보 전송 방법에 대해 설명한다.

<실시예 1>

이하의 실시예 1에서는, 도 1을 이용하여 정보 처리 시스템의 일례를 설명한다. 도 1은 실시예 1에 따른 정보 처리 시스템을 설명하기 위한 도면이다. 도 1에 도시한 예에서는, 정보 처리 시스템(1)은, 클라이언트 단말(2), 클라이언트 단말(2a), LAN(Local Area Network) 스위치(3), 관리 단말(4), LAN 스위치(5), 2중의 글로벌 크로스바(6), 복수 개의 노드(10 내지 10m)를 갖는다. 또한, 글로벌 크로스바(6)는 서비스 프로세서(7)를 갖는다.

본 실시예에 있어서, 노드는 하나의 독립된 OS(Operating System)가 주행하는 단위로서, OS가 주행하기 위해 최저한 필요한 장치를 포함한다. 나중에 상세하게 설명하겠지만, 이들은 하나 이상의 CPU, 메모리, HDD(Hard Disk Drive) 또는 HDD를 대신하는 외부 기억 장치를 갖는다. 노드는 물리적으로 단일의 장치여도 되고, 케이블 등의 장치간 접속 기능에 의해 접속되어 물리적으로 복수 개의 장치로 구성되어 있어도 된다.

각 노드(10 내지 10m)는 서비스용 LAN에 의해 LAN 스위치(3) 및 각 클라이언트 단말(2, 2a)과 접속되어 있다. 또한, 각 노드(10 내지 10m)는 내부 LAN에 의해 LAN 스위치(5)와 접속되어 있다. 또한, 각 노드(10 내지 10m)는 관리 LAN을 통해 관리 단말(4)과 접속되어 있다. 또한, 각 노드(10 내지 10m)는 2중의 글로벌 크로스바(6)와 접속되어 있으며, 인터커넥트를 통해 서로 접속되어 있다.

각 클라이언트 단말(2, 2a)은 서비스용 LAN을 통해 각 노드(10 내지 10m)로부터 서비스를 취득한다. 또한, 도 1에서는 도시를 생략했지만, 정보 처리 시스템(1)은 임의의 수의 클라이언트 단말을 가져도 된다.

노드(10)는 서비스 프로세서(11), CPU(12), 로컬 XB(크로스바)(16)를 갖는다. 또한, 다른 노드(10a 내지 10m)는, 노드(10)와 동일하게 서비스 프로세서, CPU, 로컬 XB를 갖는다. 또한, 이하의 설명에서는, 각 노드(10a 내지 10m)는 노드(10)와 동일한 기능을 발휘하는 것으로 하고 설명을 생략한다.

서비스 프로세서(11)는 관리 LAN을 통해 관리 단말(4)과 접속되어 있으며, 각 노드(10)의 전원 관리 등의 관리 제어를 실행한다. 또한, 글로벌 크로스바(6)가 갖는 서비스 프로세서(7)는 서비스 프로세서(11)의 마스터로서 동작하며, 전체의 관리 제어를 수행한다. 여기서, 각 서비스 프로세서(7, 11)가 실행하는 관리 제어의 예로는, 전원 관리, 리셋, 동작 모드의 변경, 노드의 추가나 삭제의 설정, 에러 로그의 수집, 축퇴(Degeneracy) 동작 제어 등이다.

또한, 노드(10 내지 10m)는 각각 독립적으로 OS(Operating System)를 실행한다. 또한, 도 1에서는 생략했지만, 노드(10)는, CPU(12) 이외에도 복수 개의 CPU를 가지며, 각 CPU는 로컬 XB(16)를 통해 글로벌 크로스바(6)와 접속되어 있다.

또한, 노드(10)의 CPU(12)는, 메모리 액세스의 리퀘스트인 메모리 액세스 요구를 로컬 XB(16)에 출력함으로써 다른 노드에 메모리 액세스 요구를 전송한다. 그리고, 노드(10)의 CPU(12)는, 메모리 액세스 요구를 취득하면, 자신이 자신과 접속된 메모리에 대해 액세스를 수행할 때와 동일하게 메모리 액세스를 실행한다. 즉, 정보 처리 시스템(1)에는, NUMA(Non-Uniform Memory Access)의 기술이 적용되어 있으며, 각 노드(10 내지 10m)가 각각의 메모리를 공용하여 처리를 실행한다.

다음, 도 2를 이용하여 노드(10)의 기능 구성에 대해 설명한다. 도 2는 실시예 1에 따른 노드의 기능 구성을 설명하기 위한 도면이다. 도 2에 도시한 예에서는, 노드(10)는 서비스 프로세서(11), 복수 개의 CPU(12 내지 15), 로컬 XB(16), 복수 개의 메모리(17 내지 24), PCIe(Peripheral Component Interconnect Express) 스위치(25)를 갖는다. 또한, 노드(10)는 서비스용 LAN과 접속하기 위한 LAN 어댑터(26), 관리용 LAN과 접속하기 위한 LAN 어댑터(27), SAS(Serial Attached SCSI)(28), HDD(Hard Disk Drive)(29)를 갖는다.

또한, 메모리(19) 및 메모리(20)는 CPU(13)와 접속되어 있으며, CPU(13)에 의한 메모리 액세스를 접수하는 기억 장치이다. 또한, 메모리(17) 및 메모리(18)는 CPU(12)와 접속되어 있으며, CPU(12)에 의한 메모리 액세스를 접수하는 기억 장치이다. 또한, 메모리(21) 및 메모리(22)는 CPU(14)와 접속되어 있으며, CPU(14)에 의한 메모리 액세스를 접수하는 기억 장치이다.

또한, 메모리(23) 및 메모리(24)는 CPU(15)와 접속되어 있으며, CPU(15)에 의한 메모리 액세스를 접수하는 기억 장치이다. 또한, 도 2에 도시한 예에서는, 노드(10)는 HDD(29)을 가지고 있지만, 실시예는 이에 한정되지 않으며, SAN(Storage Area Network) 등의 기술을 적용하여, 노드(10)의 외부에 설치해도 된다.

서비스 프로세서(11)는 노드(10)의 관리 제어를 실행한다. 구체적으로는, 서비스 프로세서(11)는 처리를 실행하는 프로세서와 FPGA(Field-Programmable Gate Array)를 가지며, 관리 단말(4)로부터 관리용 LAN을 통해 관리 제어의 실행 명령을 접수한다. 그리고, 서비스 프로세서(11)는 관리 단말(4)로부터 접수한 실행 명령에 따라 각종 관리 제어를 실행한다.

PCIe 스위치(25)는 각 CPU(12 내지 15)로부터 PCIe 슬롯을 통해 접속되는 I/O 장치 등으로의 액세스를 제어하는 스위치이다. 또한, LAN 어댑터(26)는 서비스용 LAN과 노드(10)를 접속하는 LAN 어댑터이다. 또한, LAN 어댑터(27)는 관리용 LAN과 노드(10)를 접속하는 LAN 어댑터이다. 또한, SAS(28)는 PCIe 슬롯에 탑재된 LAN이나 SAS용 어댑터로서, HDD(29)와 각 CPU(12 내지 15) 간의 접속을 중계한다.

다음, 각 CPU(12 내지 15)에 대해 설명한다. 각 CPU(12 내지 15)는 서로 접속되어 있으며, 메모리 액세스 요구나 응답을 서로 송수신할 수 있다. 이하, CPU(12)에 대해 설명한다. 또한, CPU(12)는 다른 CPU(13 내지 15)와 서로 접속되어 있다. 또한, CPU(13 내지 15)는 CPU(12)와 동일한 기능을 발휘하는 것으로 하고 설명을 생략한다.

CPU(12)는 메모리(19) 및 메모리(20)에 대해 메모리 액세스를 수행하는 메모리 인터페이스의 기능을 가지며, 메모리(19) 또는 메모리(20)가 기억하는 데이터를 캐시하고, 캐시한 데이터를 이용하여 연산 처리를 실행한다. 또한, CPU(12)는 PCIe 스위치(25)를 통해 HDD(29)나 내부 LAN, 관리용 LAN 등을 이용한 액세스를 제어하는 PCIe 인터페이스 기능을 갖는다.

또한, CPU(12)는 로컬 XB(16), 글로벌 크로스바(6)를 통해 다른 노드(10a 내지 10m)가 갖는 CPU와 인터커넥트로 접속되며, 서로 메모리 액세스의 요구 등을 송수신하는 인터커넥트 라우터 기능을 갖는다. 이러한 CPU(12)는, 예컨대, 실행하는 프로세스에 의해 메모리(19) 또는 메모리(20)에 대한 메모리 액세스 요구가 발행된 경우에는, 이하의 처리를 실행한다. 즉, CPU(12)는 메모리(19) 또는 메모리(20)에 액세스하고, 액세스 대상이 되는 데이터를 캐시한다.

또한, CPU(12)는, 실행하는 프로세스에 의해 메모리(19), 메모리(20) 이외의 메모리에 대한 메모리 액세스 요구가 발행된 경우에는, 메모리 액세스 대상이 되는 메모리와 접속된 CPU를 식별하고, 식별한 CPU에 대해 메모리 액세스 요구를 송신한다. 구체적으로 설명하면, CPU(12)는 액세스 대상이 되는 메모리 어드레스와, 메모리 어드레스가 나타내는 기억 영역에 액세스하는 CPU를 일의(一意)로 나타내는 정보를 대응시킨 노드 맵을 갖는다.

그리고, CPU(12)는, 프로세스가 메모리 액세스 요구를 발행한 경우에는, 노드 맵을 참조하여, 메모리 액세스의 대상이 되는 메모리 어드레스에 대응시켜진 CPU를 식별한다. 그 후, CPU(12)는 식별한 CPU를 수신처로 하는 패킷을 생성하고, 생성한 패킷에 메모리 액세스 요구를 저장하여, CPU(12 내지 15)의 상호 접속 또는 로컬 XB(16)에 출력한다. 로컬 XB(16)에 출력된 경우에는, 로컬 XB(16)는 글로벌 크로스바(6)를 통해 패킷을 수신처가 되는 CPU에 송신한다.

또한, CPU(12)는 메모리(19) 및 메모리(20)에 대한 메모리 액세스를 실행하는 경우에는, 메모리(19) 또는 메모리(20)로부터 캐시된 데이터의 코히런시를 유지하는 처리를 실행한다. 예컨대, CPU(12)는 메모리(19) 또는 메모리(20)로부터 데이터를 캐시한 CPU에 대해 스누프를 송신하고, 캐시된 데이터의 라이트 백을 실행한다.

로컬 XB(16)는 노드(10)가 갖는 CPU(12 내지 15)와, 다른 노드(10a 내지 10m)가 갖는 CPU 사이에서 주고받는 패킷을 지정 상대방에게 전송하기 위한 스위치이다. 예컨대, 로컬 XB(16)는, CPU(12)가 CPU(12a)를 수신처로 하여 발행한 패킷을 글로벌 크로스바(6)를 통해 노드(10a)가 갖는 CPU(12a)에 송신한다.

메모리(17) 내지 메모리(24)는 OS나 애플리케이션이 이용하는 데이터를 기억하는 메모리로서, 예컨대, DIMM(Dual In-Line Memory Module)이다. 또한, 메모리(17 내지 24)는 동일한 메모리 어드레스 공간에 매핑되어 있다.

또한, 메모리(17 내지 24)는 동일 노드 내의 CPU(12 내지 15) 만이 액세스 가능한 영역, 즉 자신을 갖는 노드 전용의 영역인 로컬 영역을 갖는다. 또한, 메모리(17 내지 24)는 정보 처리 시스템(1)이 갖는 임의의 CPU가 액세스 가능한 영역, 즉, 모든 노드가 이용 가능한 공유 메모리 영역을 갖는다. 또한, 메모리(17 내지 24)의 공유 메모리 영역은 복수 개의 세그멘트로 분할된다. 그리고, 각 세그멘트는 메모리 토큰(memory token)에 의한 액세스 제어가 수행되는 프로텍트 영역 또는 메모리 토큰에 의한 액세스 제어를 수행하지 않는 넌프로텍트 영역이 된다.

여기서, 도 3, 도 4를 이용하여 각 메모리(17 내지 24)에 매핑되는 메모리 어드레스에 대해 설명한다. 도 3은 실시예 1에 따른 메모리의 할당을 설명하기 위한 도면이다. 예컨대, 정보 처리 시스템(1)은 각 CPU(12 내지 15)에 접속된 2개의 메모리 중 하나의 메모리를 로컬 영역만의 메모리로 하고, 다른 하나의 메모리를 공용 메모리 영역만의 메모리로 한다. 즉, 도 3 중 (a)에 도시한 바와 같이, 메모리(17), 메모리(19), 메모리(21), 메모리(23)를 노드 전용의 메모리로 하고, 도 3 중 (b)에 도시한 바와 같이, 메모리(18), 메모리(20), 메모리(22), 메모리(24)를 공용하는 메모리로 한다.

도 4는 실시예 1에 따른 정보 처리 시스템이 각 메모리에 매핑하는 메모리 맵을 설명하기 위한 도면이다. 또한, 도 4에는 총 128테라바이트의 메모리 어드레스 공간이 준비되고, 그 중 로컬 영역에 64테라바이트가 할당되고, 공유 메모리 영역에 64테라바이트가 할당되는 예에 대해 도시한다.

예컨대, 정보 처리 시스템(1)은 노드(10 내지 10m)가 갖는 메모리 중 로컬 영역으로서 사용할 범위에 "0"부터 "2⁴⁶-1"까지의 메모리 어드레스를 할당한다. 또한, 정보 처리 시스템(1)은 노드(10 내지 10m)가 갖는 메모리 중 공유 메모리 영역으로서 사용할 범위에 "2⁴⁶"부터 "2⁴⁷-1"까지의 메모리 어드레스를 할당한다.

즉, 도 3 및 도 4에 도시한 예에서는, 정보 처리 시스템(1)은 도 3 중 (a)에 도시한 메모리(17), 메모리(19), 메모리(21), 메모리(23)에 대해 도 4 중 (c)에 도시한 범위의 메모리 어드레스를 매핑한다. 또한, 정보 처리 시스템(1)은, 도 3 중 (b)에 도시한 메모리(18), 메모리(20), 메모리(22), 메모리(24)에 대해 도 4 중 (d)에 도시한 범위의 메모리 어드레스를 매핑한다. 또한, 도 4 중의 "2⁴⁷"부터 "2⁴⁸-1"까지의 어드레스는 UC(Uncacheable) 영역으로서 사용되는 어드레스의 범위이며, 예컨대, HDD(29) 등의 I/O 장치가 사용하는 I/O 공간으로서 사용되는 어드레스의 범위이다.

이와 같이 정보 처리 시스템(1)은 각 노드(10 내지 10m)가 갖는 메모리에 대해 단일의 메모리 어드레스 공간을 매핑한다. 따라서, 임의의 CPU가 임의의 노드의 공유 메모리 영역에 대해 직접 액세스할 수 있다. 또한, 도 4에 도시한 메모리 맵은 어디까지나 일례로서, 임의의 할당을 수행하는 것으로 해도 된다.

즉, 메모리 맵 상의 메모리 어드레스가 모두 메모리에 할당되어 있을 필요는 없으며, 메모리 홀이 존재해도 된다. 또한, 정보 처리 시스템(1)이 갖는 각 노드에 OS가 이용하는 로컬 영역이 존재하며, 하나 이상의 노드에 공유 메모리 영역이 존재하도록 메모리 맵을 설정하면 된다.

또한, 정보 처리 시스템(1)은 하나의 노드 내에 포함되는 메모리(예컨대, 메모리(17)와 메모리(18))에 대해 연속되는 메모리 어드레스를 맵한 경우에는, 제어 자원을 삭감할 수 있다. 또한, 정보 처리 시스템(1)은 적어도 세그멘트 영역의 얼라인먼트를 맞추도록 메모리 어드레스의 할당을 수행한다.

다음, 도 5를 이용하여 각 CPU(12 내지 15)의 하드웨어와 각 CPU(12 내지 15)가 실행하는 소프트웨어의 관계에 대해 설명한다. 도 5는, 실시예 1에 따른 정보 처리 시스템에 있어서 하드웨어와 소프트웨어의 관계를 설명하기 위한 도면이다. 또한, 도 5에 도시한 예에서는 CPU(12)가 갖는 하드웨어를 하드웨어(30)로 하고, CPU(13)가 갖는 하드웨어를 하드웨어(30a)로 했다. 또한, 도 5에 도시한 예에서는, CPU(14)가 갖는 하드웨어를 하드웨어(30b)로 하고, CPU(15)가 갖는 하드웨어를 하드웨어(30c)로 했다.

예컨대, CPU(12)는 하드웨어(30)를 가지며, CPU(12) 전용의 로컬 메모리(17) 및 공유 메모리(18, 20, 22, 24)에 액세스한다. 또한, CPU(12)는 하드웨어(30) 상에서 하이퍼바이저(31), 오퍼레이팅 시스템(32), 드라이버(33), 미들웨어(34)를 동작시킨다. 또한, CPU(12)는 미들웨어(34) 상에 각 CPU(12 내지 15)가 협조하여 동작시키는 애플리케이션(35)을 실행한다.

또한, 다른 CPU(13 내지 15)는, CPU(12)와 마찬가지로 하드웨어(30a 내지 30c)를 가지며, 하이퍼바이저(31a 내지 31c), 오퍼레이팅 시스템(32a 내지 32c), 드라이버(33a 내지 33c), 미들웨어(34a 내지 34c)를 동작시킨다.

다음, 도 6을 이용하여 실시예 1에 따른 CPU(12 내지 15)가 실행하는 처리의 개요에 대해 설명한다. 또한, 이하의 설명에서는, CPU(13 내지 15)는 CPU(12)와 동일한 기능을 발휘하는 것으로 하고 설명을 생략한다.

도 6은 실시예 1에 따른 CPU가 실행하는 처리의 개념을 설명하기 위한 도면이다. 도 6에는 CPU(12)가 실행하는 복수 개의 송신 프로세스 #1 내지 #6이, 수신측의 CPU(13)가 실행하는 수신 프로세스 #1 내지 #n에 대해 메시지를 송신하는 처리의 개요에 대해 기재했다. 예컨대, CPU(12)는 복수 개의 코어와 각 코어마다의 송신 버퍼를 갖는다. 또한, CPU(13)는 실행하는 수신 프로세스마다의 수신 큐 #1 내지 #n을 갖는다.

예컨대, 각 코어는 OS(32) 상에서 동작하는 복수 개의 송신 프로세스 #1 내지 #6 중 어느 하나의 송신 프로세스를 동작시킨다. 예컨대, 도 6에 도시한 예에서는, 각 코어는 송신 프로세스 #2 내지 #5를 동작시킨다. 그리고, 각 코어는 실행중인 송신 프로세스가 메시지를 CPU(13)에 송신하는 경우에는 송신하는 메시지를 송신 버퍼에 저장한다.

또한, 각 송신 버퍼는, 각 코어가 실행하는 프로세스의 메시지가 저장되면, 메시지를 수신하는 수신 프로세스에 따라 CPU(13)가 갖는 수신 큐 #1 내지 #n 중 어느 하나에 저장한다. 그리고, 각 수신 프로세스 #1 내지 #n은, CPU(13)에 의해 실행되었을 때에 자신의 수신 큐에 저장된 메시지를 취득한다.

또한, 하나의 코어가 복수 개의 스레드를 동시에 실행할 수 있는 것이면, CPU(12)는 송신 버퍼 레지스터를 스레드마다 갖는다. 그리고, CPU(12)는 컨텍스트 스위치가 발생했을 때에, 송신 버퍼 레지스터에 저장된 데이터의 세이브나 리스토어를 수행함으로써, 가상적으로 송신 프로세스의 수와 동일한 송신 버퍼를 갖도록 동작한다.

다음, 도 7을 이용하여 정보 처리 시스템(1)에 있어서 각 CPU가 실행하는 프로세스가 프로세스간 통신을 수행하는 처리의 흐름에 대해 설명한다. 도 7은 실시예 1에 따른 프로세스간 통신의 처리의 흐름을 설명하기 위한 도면이다. 또한, 도 7에 도시한 예에서는, 하드웨어(30, 30a) 상에서 동작하는 송신 프로세스 #A, #B가, 하드웨어(30c) 상에서 동작하는 수신 프로세스에 대해 메시지를 송신하는 처리의 흐름에 대해 설명한다.

예컨대, 도 7에 도시한 예에서는, 하드웨어(30) 및 하드웨어(30a)는, 송신하는 메시지를 일시적으로 기억하는 송신 레지스터를 갖는다. 또한, 메시지를 수신하는 하드웨어(30c)는, 리드 포인터와 라이트 포인터를 대응시킨 복수 개의 레지스터 세트와, 메시지를 수신하는 수신 버퍼를 갖는다.

먼저, 하드웨어(30c)가 실행하는 수신 프로세스는, 도 7 중 (a)에 도시한 바와 같이, 공유 메모리 상 또는 로컬 메모리 상에 메시지를 저장하는 영역을 미리 설정한다. 다음, 수신 프로세스는, 도 7 중 (b)에 도시한 바와 같이, 드라이버(33c)를 호출하여, 레지스터 세트 자원의 획득 및 초기화를 수행한다. 다음, 수신 프로세스는, 도 7 중 (c)에 도시한 바와 같이, 획득한 레지스터 세트를 일의로 나타내는 레지스터 ID를 송신 프로세스 #A 및 송신 프로세스 #B에 통지한다.

그러면, 송신 프로세스 #A는, 수신 프로세스로부터 통지받은 레지스터 ID와 송신 메시지 #A를 포함하는 메시지 #A를 생성하고, 도 7 중 (d)에 도시한 바와 같이, 하드웨어(30)가 갖는 송신 레지스터에 저장한다. 또한, 송신 프로세스 #B는 수신 프로세스로부터 통지받은 레지스터 ID와 송신 메시지 #B를 포함하는 메시지 #B를 생성하고, 도 7 중 (e)에 도시한 바와 같이, 하드웨어(30)가 갖는 송신 레지스터에 저장한다.

또한, 하드웨어(30, 30a)는 송신 레지스터에 메시지 #A, #B가 저장되면, 각 메시지를 패킷화한다. 그리고, 하드웨어(30, 30a)는, 도 7 중 (f)에 도시한 바와 같이, 노드간 인터커넥트를 통해 하드웨어(30c)가 갖는 수신 버퍼에 저장한다. 그러면 하드웨어(30c)는, 수신한 패킷에 포함되는 레지스터 ID를 식별하고, 식별한 레지스터 ID가 나타내는 레지스터 세트의 라이트 포인터가 나타내는 기억 영역에 메시지를 저장한다. 예컨대, 하드웨어(30c)는, 도 7 중 (g)에 도시한 바와 같이, 동일한 레지스터 세트의 라이트 포인터가 나타내는 기억 영역으로부터 메시지 #A 및 메시지 #B를 순서대로 저장한다.

여기서, 수신 프로세스는, 도 7 중 (h)에 도시한 바와 같이, 폴링(polling)에 의한 감시 또는 인터럽트 처리의 발생을 이용하여 메시지의 착신을 검지한다. 그리고, 수신 프로세스는, 송신 프로세스 #A 및 송신 프로세스 #B에 통지한 레지스터 ID가 나타내는 레지스터 세트의 리드 포인터를 이용하여, 도 7 중 (i)에 도시한 바와 같이, 메시지 #A 및 메시지 #B의 판독을 수행한다.

이와 같이 실시예 1에 따른 프로세스간 통신에 있어서는, 메시지 수신측의 CPU가 복수 개의 레지스터 세트를 가지며, 메시지 송신측의 CPU에 대해 레지스터 세트를 식별하는 레지스터 식별자를 송신한다. 그러면, 메시지 송신측의 CPU는 레지스터 식별자와 함께, 메시지를 메시지 수신측의 CPU에 송신한다. 그 후, 메시지 수신측의 CPU는, 수신한 레지스터 식별자가 나타내는 레지스터 세트의 라이트 포인터를 이용하여 수신한 메시지의 저장을 수행한다.

이 결과, 각 CPU(12 내지 15)는, 리드 포인터나 라이트 포인터를 캐시하지 않고도, 큐를 이용한 프로세스간 통신을 실현할 수 있다. 따라서, 각 CPU(12 내지 15)는 어느 하나의 CPU에 고장이 생겼을 때에도, 리드 포인터나 라이트 포인터의 판독을 할 수 없는 일이 없기 때문에, 고장의 파급을 방지할 수 있다.

또한, 각 CPU(12 내지 15)는 자신에 대해 동시에 메시지를 송신하는 프로세스의 수, 동시에 메시지를 송신하는 프로세스의 수보다 많은 레지스터 세트를 갖는다. 즉, 각 CPU(12 내지 15)는 동시에 메시지를 수신하는 프로세스의 수만큼 레지스터 세트를 갖는다. 이 결과, 각 CPU(12 내지 15)는, 임의의 프로세스를 실행중에 레지스터 세트가 부족해져, 프로세스간 통신을 할 수 없게 되는 사태를 방지할 수 있다.

다음, 도 8을 이용하여 CPU(12)의 기능 구성의 일례에 대해 설명한다. 도 8은 실시예 1에 따른 CPU의 기능 구성을 설명하기 위한 도면이다. 도 8에 도시한 예에서는, CPU(12)는 로컬 XB(16), 메모리(17), 메모리(18), PCIe 스위치(25)와 접속되어 있다. 또한, CPU(12)는 복수 개의 코어(40 내지 40b), L1 캐시 태그(41 내지 41b), L1 캐시(42 내지 42b), TLB(Translation Lookaside Buffer)(43 내지 43b)를 갖는다.

또한, CPU(12)는 L2 캐시 액세스 컨트롤러(44), L2 캐시 태그(45), L2 캐시(46), 어드레스 맵(47), 설정 레지스터군(48), PCI 제어부(49), 디렉토리 제어부(50), 캐시 코히런시 트랜잭션 제어부(51), MSGQ(메시지 큐) 제어부(56)를 갖는다. 또한, MSGQ 제어부(56)는 송신 제어부(57), 수신 제어부(58)를 갖는다.

또한, 어드레스 맵(47), PCI 제어부(49), 디렉토리 제어부(50), 캐시 코히런시 트랜잭션 제어부(51), MSGQ 제어부(56)는, 메모리 R/W(Read/Write) 버스(53)를 통해 접속되어 있다. 또한, 각 코어(40 내지 40b), 어드레스 맵(47), 설정 레지스터군(48), PCI 제어부(49), 디렉토리 제어부(50), 캐시 코히런시 트랜잭션 제어부(51), MSGQ 제어부(56)는, 레지스터 R/W 버스(54)를 통해 접속되어 있다.

한, 코어(40a), 코어(40b)에 대해서는 코어(40)와 동일한 기능을 발휘하는 것으로 하고 이하의 설명을 생략한다. 또한, L1 캐시 태그(41a), L1 캐시 태그(41b)는 L1 캐시 태그(41)와 동일한 기능을 발휘하고, L1 캐시(42a), L1 캐시(42b)는 L1 캐시(42)와 동일한 기능을 발휘하는 것으로 하고 이하의 설명을 생략한다. 또한, TLB(43a), TLB(43b)는 TLB(43)와 동일한 기능을 발휘하는 것으로 하고 이하의 설명을 생략한다.

코어(40)는 L1 캐시(42)에 저장된 데이터를 이용하여 연산 처리를 실행하는 연산 장치로서, 명령 실행 유닛 및 연산 유닛을 갖는다. 또한, 코어(40)는, CPU(12) 이외의 CPU가 실행하는 프로세스에 대해 메시지의 송신을 수행하는 경우에는, 이하의 처리를 실행한다.

먼저, 코어(40)는 메시지의 송신처가 되는 CPU가 실행하는 프로세스로부터, 레지스터 세트를 나타내는 레지스터 ID를 취득한다. 또한, 코어(40)는 송신처의 CPU로부터 수신한 레지스터 ID와, 메시지의 송신처가 되는 CPU를 나타내는 CPU-ID를 포함하는 MSGQ-ID를 생성한다. 그리고, 코어(40)는 송신하는 메시지와, MSGQ-ID를 MSGQ 제어부(56)의 송신 제어부(57)에 송신한다. 또한, 코어(40)는, 메시지의 송신처가 되는 CPU의 어드레스와, 송신을 요구하는 커맨드를 송신 제어부(57)에 송신한다.

또한, 코어(40)는 CPU(12) 이외의 CPU가 실행하는 프로세스로부터, 메시지의 수신을 수행하는 경우에는, MSGQ 제어부(56)가 기억하는 레지스터 세트를 획득하고, 획득한 레지스터 세트를 나타내는 레지스터 ID를 취득한다. 그리고, 코어(40)는 취득한 레지스터 ID를 메시지 송신원의 CPU가 실행하는 프로세스에 대해 통지한다. 또한, 코어(40)는 임의의 방법을 이용하여, CPU(12) 이외의 CPU가 실행하는 프로세스에 대해 레지스터 ID를 통지할 수도 있다.

또한, 코어(40)가 메시지와 MSGQ-ID를 MSGQ 제어부(56)의 송신 제어부(57)에 송신하는 처리는, 레지스터 R/W 버스(54)를 통해 실행된다. 즉, 코어(40)는 송신 대상이 되는 메시지와 MSGQ-ID를 송신 제어부(57)가 갖는 레지스터에 기입하는 스토어 요구를 발행함으로써, 메시지와 MSGQ-ID를 송신 제어부(57)에 송신한다.

L1 캐시 태그(41)는 L1 캐시(42)의 태그 데이터로서, L1 캐시(42)의 각 캐시 라인에 저장된 데이터의 어드레스, 스테이트, 리플레이스용의 LRU(Least Recently Used) 정보 등을 기억한다. L1 캐시(42)는, 고속으로 액세스 가능한 캐시 메모리로서, 메모리(17), 메모리(18), L2 캐시(46)에 저장된 데이터의 일부를 캐시한다.

또한, L1 캐시(42)는 코어(40) 전용의 일차 캐시이다. 예컨대, L1 캐시(42)는 명령용의 영역과 데이터용의 영역에 각각 64킬로바이트의 용량을 갖는다. 또한, TLB(43)는 변환 테이블을 이용하여 코어(40)가 출력하는 가상 어드레스를 물리 어드레스로 변환한다.

L2 캐시 액세스 컨트롤러(44)는, L2 캐시 태그(45)나 L2 캐시(46)의 액세스 컨트롤러로서, L2 캐시 태그(45)나 L2 캐시(46)에 액세스하기 위한 파이프 라인이다. 또한, L2 캐시 액세스 컨트롤러(45)는 동일 어드레스를 시리얼라이즈 처리하는 기능을 갖는다.

L2 캐시 태그(45)는 L2 캐시(46)의 태그 데이터로서, L1 캐시 태그(41)와 동일한 정보를 기억한다. 또한, L2 캐시(46)는 각 코어(40 내지 40b)가 공용하는 2차 캐시 메모리이다. 어드레스 맵(47)은, 리퀘스트 대상이 되는 물리 어드레스와, 물리 어드레스가 나타내는 기억 영역에 액세스하는 CPU의 식별자를 대응시켜 기억하며, 물리 어드레스를 CPU의 식별자로 변환한다.

즉, 어드레스 맵(47)은, CPU(12)가 다른 CPU와 접속된 메모리에 액세스하는 리퀘스트를 발행하면, 액세스 대상인 물리 어드레스로부터 리퀘스트의 송신처가 되는 CPU의 식별자를 판별한다. 그리고, 어드레스 맵(47)은 디렉토리 제어부(50)나 캐시 코히런시 트랜잭션 제어부(51)에 CPU의 식별자를 통지한다.

설정 레지스터군(48)은, CPU(12)의 각종 설정을 수행하는 복수 개의 레지스터로서, 레지스터 R/W 버스(54)를 통해 코어(40 내지 40b)로부터의 스토어 요구 등에 의해 데이터가 저장된다. PCI 제어부(49)는 CPU 접속의 PCIexpress에 대한 루트 컴플렉스이다.

디렉토리 제어부(50)는 NUMA의 기술을 이용한 메모리 액세스를 제어한다. 또한, 디렉토리 제어부(50)는 DMA(Direct Memory Access) 등의 메모리 리퀘스트를 취득하면, 메모리(17), 메모리(18)에 저장된 디렉토리 정보를 이용하여 캐시 코히런시를 유지하는 처리를 실행한다. 예컨대, 디렉토리 제어부(50)는, 캐시 코히런시 트랜잭션 제어부(51)를 이용하여, 다른 CPU에 스누프를 발행하거나 다른 CPU가 발행한 스누프에 대한 응답 등을 실행한다.

캐시 코히런시 트랜잭션 제어부(51)는, 로컬 XB(16)를 통해 CPU(12) 이외의 CPU로부터의 스누프를 접수하면, L2 캐시(46)를 검사하고, 검사 결과를 응답으로서 회신한다. 또한, 캐시 코히런시 트랜잭션 제어부(51)는, 디렉토리 제어부(50)로부터 스누프의 발행을 요구받은 경우에는, 스누프를 CPU(12) 이외의 CPU에 대해 송신한다. 예컨대, 캐시 코히런시 트랜잭션 제어부(51)는, L2 캐시(46)에 저장된 스누프 대상의 데이터의 스테이트가 "M"인 경우에는, 캐시 데이터를 스누프의 응답으로서 송신한다.

MSGQ 제어부(56)는 다른 CPU(13 내지 15)나 다른 노드(10a 내지 10m)가 실행하는 프로세스와, CPU(12)가 실행하는 프로세스 사이의 프로세스간 통신을 제어한다. 구체적으로는, MSGQ 제어부(56)는, 메시지의 기입 시작 위치를 나타내는 라이트 포인터와, 메시지의 판독 시작 위치를 나타내는 리드 포인터와의 세트인 레지스터 세트를 복수 개 기억한다.

또한, MSGQ 제어부(56)는, 코어(40 내지 40b)가 실행하는 프로세스가 CPU(12) 이외의 CPU가 실행하는 프로세스로부터 메시지를 수신하는 경우에는, 사용하지 않은 레지스터 세트를 획득한다. 그 후, MSGQ 제어부(56)는, 획득한 레지스터 세트를 나타내는 레지스터 ID를 코어(40 내지 40b)가 실행하는 프로세스에 통지한다. 그리고, MSGQ 제어부(56)는 코어(40 내지 40b)로부터 송신하는 메시지와 레지스터 식별자를 수신하면, 수신한 메시지와 MSGQ-ID를 포함하는 패킷을 생성하고, 로컬 XB(16)를 통해 패킷을 송신한다.

또한, MSGQ 제어부(56)는 레지스터 세트를 복수 개 기억하고, 다른 CPU(13 내지 15)나 다른 노드(10a 내지 10m)로부터 패킷을 수신한 경우에는, 수신한 패킷에 포함되는 MSGQ-ID로부터 레지스터 ID를 추출한다. 그리고, MSGQ 제어부(56)는 추출한 레지스터 ID가 나타내는 레지스터 세트를 식별한다. 그리고, MSGQ 제어부(56)는, 식별한 레지스터 세트의 라이트 포인터가 나타내는 기억 영역에, 수신한 패킷에 포함되는 메시지를 저장한다. 또한, MSGQ 제어부(56)는, 메시지를 저장하는 경우에는 메모리 R/W 버스(53)를 통해 디렉토리 제어부(50)에 메시지를 전송한다. 이러한 경우에는, 디렉토리 제어부(50)는 수신한 메시지를 메모리(17, 18)에 저장한다.

로컬 XB(16)는, 인터커넥트용의 라우터로서, CPU의 식별자에 대응한 수신처에 리퀘스트를 송신한다. 또한, 로컬 XB(16)는 송신하는 리퀘스트의 패킷화나 CRC(Cyclic Redundancy Check)의 부가 등을 수행한다.

다음, 도 9를 이용하여 송신 제어부(57)의 기능 구성에 대해 설명한다. 도 9는 실시예 1에 따른 송신 제어부의 기능 구성을 설명하기 위한 도면이다. 도 9에 도시한 예에서는, 송신 제어부(57)는, 어드레스 디코더(59), 복수 개의 제어 자원(60 내지 60c), 셀렉터(69), 리드 데이터 셀렉터(70)를 갖는다. 또한, 각 제어 자원(60 내지 60c)은, 메시지 데이터 레지스터(61), MSGQ-ID 레지스터(62), 발행 요구 플래그 레지스터(63), 송신 패킷 생성부(64), 셀렉터(65), 응답 스테이터스 레지스터(66), 리드 데이터 셀렉터(67), 응답 수신 플래그 레지스터(68)를 갖는다.

여기서, 제어 자원(60)은 코어(40)용의 제어 자원이고, 다른 제어 자원(60a, 60b)은 각각 코어(40a, 40b)용의 코어 자원이고, 제어 자원(60c)은, 도 8에 있어서 기재를 생략한 다른 코어용의 제어 자원이다. 또한, 도 9에 도시한 예에서는, 제어 자원(60)에 대해서만 기능 구성을 기재했지만, 다른 제어 자원(60a 내지 60c)은 제어 자원(60)과 동일한 기능 구성을 갖는 것으로 한다. 또한, 도 9에 도시한 예에서는 각 코어(40 내지 40b)마다의 제어 자원을 기재했지만, CPU(12)는 동시에 실행 가능한 프로세스의 수만큼 제어 자원(60 내지 60c)을 갖는 것으로 한다.

먼저, 제어 자원(60)이 갖는 각 레지스터에 대해 설명한다. 여기서, 메시지 데이터 레지스터(61), MSGQ-ID 레지스터(62), 발행 요구 플래그 레지스터(63), 응답 스테이터스 레지스터(66), 응답 수신 플래그 레지스터(68)에는, 각각 어드레스가 부여되어 있다. 그리고, 각 코어(40 내지 40b)는, 각 레지스터에 저장하는 데이터를 송신하고, 데이터를 저장하는 레지스터의 어드레스와 라이트 요구를 발행함으로써 데이터를 각 레지스터에 저장한다. 또한, 각 코어(40 내지 40b)는, 각 레지스터의 어드레스와 리드 요구를 발행함으로써 각 레지스터의 값을 판독할 수 있다.

도 10은 각 레지스터에 부여되는 어드레스의 일례를 설명하기 위한 도면이다. 또한, 도 10에는 각 레지스터에 부여되는 어드레스, 각 레지스터에 대해 발행 가능한 커맨드, 각 레지스터에 저장하는 데이터의 사이즈, 각 레지스터에 저장하는 데이터의 의미, 컨텍스트 스위치시에 세이브 및 리스토어의 대상으로 할 것인지 여부를 기재했다. 코어(40)가 실행하는 프로세스는, 도 10에 도시한 어드레스와 함께, 리드 요구 또는 라이트 요구를 발행함으로써 제어 자원(60)이 갖는 각 레지스터의 값을 조작할 수 있다.

예컨대, 메시지 데이터 레지스터(61)는, 송신하는 메시지를 기억하는 레지스터이다. 도 10에 도시한 예에서는, 메시지 데이터 레지스터(61)는, 어드레스 "0x00" 내지 "0x3F"가 부여되고, 리드 요구 또는 라이트 요구의 대상이 되는 레지스터이며, 32바이트 또는 64바이트의 데이터가 저장된다. 또한, 메시지 데이터 레지스터(61)는 컨텍스트 스위치 시에 세이브 및 리스토어의 대상이 되는 레지스터이다.

또한, MSGQ-ID 레지스터(62)는 MSGQ-ID를 기억하는 레지스터이다. 도 10에 도시한 예에서는, MSGQ-ID 레지스터(62)는, 어드레스 "0x40" 내지 "0x47"이 부여되고, 리드 요구 또는 라이트 요구의 대상이 되는 레지스터이며, 32비트의 데이터가 저장된다. 또한, MSGQ-ID 레지스터(62)는 컨텍스트 스위치 시에 세이브 및 리스토어의 대상이 되는 레지스터이다.

여기서, 도 11을 이용하여 MSGQ-ID 레지스터(62)에 저장하는 데이터의 일례에 대해 설명한다. 도 11은 MSGQ-ID의 포맷의 일례를 설명하기 위한 도면이다. 도 11에 도시한 바와 같이, MSGQ-ID는 메시지의 송신처가 되는 CPU의 CPU 번호, 레지스터 세트의 번호, 레지스터 세트에 대한 액세스의 여부를 판단하기 위한 액세스 키, 메시지 사이즈를 저장하는 필드를 갖는다.

다음, 도 12를 이용하여 MSGQ-ID의 각 필드에 저장하는 정보의 내용에 대해 설명한다. 도 12는 MSGQ-ID의 각 필드에 저장되는 정보를 설명하기 위한 도면이다. 예컨대, CPU-ID[7:0]는 메시지의 송신처가 되는 CPU를 나타내는 8비트의 정보이다.

또한, 레지스터 ID란, 레지스터 세트를 나타내는 11비트의 번호이며, CPU-ID와 합함으로써 정보 처리 시스템(1) 전체의 유니크한 수신처를 나타낸다. 또한, 액세스 키란, 액세스의 여부를 판별하기 위해 사용하는 12비트의 키 정보이며, 메시지 수신측의 프로세스가 임의로 결정하고, 메시지 송신측의 프로세스에 대해 통지되는 정보이다. 또한, M 사이즈란, 송신하는 메시지의 사이즈를 나타내는 정보이며, 값이 "0"인 경우에는 송신하는 메시지가 32바이트인 취지를 나타내고, 값이 "1"인 경우에는 송신하는 메시지가 64바이트인 취지를 나타낸다.

도 10으로 돌아가, 발행 요구 플래그 레지스터(63)는, 코어(40)가 메시지의 송신을 요구할 때에 플래그를 저장하는 레지스터이다. 도 10에 도시한 예에서는, 발행 요구 플래그 레지스터(63)는 어드레스 "0x48" 내지 "0x4F"가 부여되고, 라이트 요구의 대상이 되는 레지스터이며, 1비트의 데이터, 즉 플래그가 저장된다. 후술하는 송신 패킷 생성부(64)는, 코어(40)가 발행 요구 플래그 레지스터(63)에 "1"을 저장하면, 메시지와 MSGQ-ID를 포함하는 패킷을 수신처에 송신하게 된다. 또한, 발행 요구 플래그 레지스터(63)는 컨텍스트 스위치 시에 세이브 및 리스토어의 대상이 되지 않는다.

응답 스테이터스 레지스터(66)는 메시지를 송신한 CPU로부터의 응답이 정상적으로 수신되었는지 여부를 나타내는 응답 스테이터스를 기억하는 레지스터이다. 도 10에 도시한 예에서는, 응답 스테이터스 레지스터(66)는, "0x50" 내지 "0x57"의 어드레스가 부여되고, 리드 요구 또는 라이트 요구의 대상이 되는 레지스터이며, PROT 비트와 OVFL 비트 2비트의 데이터가 저장된다. 여기서, PROT 비트란, 키 정보에 액세스 여부의 판별 결과를 나타내는 비트이고, OVFL 비트란, 오버플로우가 발생했는지 여부의 판별 결과를 나타내는 비트이다. 또한, 도 10에서는 기재를 생략했지만, 응답 수신 플래그 레지스터(68)는 메시지의 응답을 수신했는지 여부를 나타내는 플래그를 기억하는 레지스터이다.

또한, 도 10에 도시된 각 레지스터는, 소프트웨어로부터 액세스를 수행하기 쉽도록, 데이터의 유효 길이가 8바이트(64비트) 이내라 하더라도 8바이트 바운더리에 맞추어진 어드레스 영역을 점유한다. 또한, 각 레지스터가 점유하는 어드레스 영역에 있어서, 데이터의 유효 길이 이외의 부분의 값은 의미를 갖지 않는 것으로 한다. 또한, 각 코어(40 내지 40b)는, 자신에 대응하는 제어 자원(60 내지 60b)의 레지스터에 대해서만 리드 및 라이트가 저장되며, 다른 제어 자원에 대한 리드 및 라이트를 수행할 수 없다.

도 9로 돌아가, 어드레스 디코더(59)는 레지스터 R/W 버스(54)를 통해 코어(40)로부터 어드레스와 커맨드를 수신하면, 수신한 어드레스와 커맨드를 디코딩하고, 제어 자원(60)이 갖는 레지스터에 저장한다. 예컨대, 어드레스 디코더(59)는 코어(40)로부터 커맨드와 어드레스를 수신하면 수신한 커맨드와 어드레스를 디코딩하고, 디코딩한 커맨드와 어드레스를 제어 자원(60)에 통지한다. 그러면, 제어 자원(60)은, 어드레스 디코더(59)로부터 수신한 어드레스가 나타내는 레지스터를 대상으로 한 데이터의 판독 또는 기입을 실행한다.

송신 패킷 생성부(64)는, 발행 요구 플래그 레지스터(63)에 "1"이 저장되면, 메시지 데이터 레지스터(61)에 저장된 메시지와, MSGQ-ID 레지스터(62)에 저장된 MSGQ-ID를 취득한다. 그리고, 송신 패킷 생성부(64)는, 취득한 메시지와 MSGQ-ID를 갖는 패킷을 생성하고, 생성한 패킷을 셀렉터(69)에 출력한다.

여기서, 도 13은 패킷 포맷의 일례를 설명하기 위한 도면이다. 도 13에 도시한 바와 같이, 송신 패킷 생성부(64)는, 포맷, 송신처 CPU 번호, 오퍼레이션 코드, 송신원 CPU 번호, 엔트리 ID, MSGQ-ID, 데이터가 저장된 패킷을 생성한다. 여기서, 포맷에는 패킷의 포맷 타입을 나타내는 4비트의 정보가 저장된다.

송신처 CPU 번호에는, 송신처의 CPU를 나타내는 ID, 즉 8비트의 DID(Destination ID)가 저장된다. 또한, 송신 패킷 생성부(64)는, MSGQ-ID 레지스터(62)에 저장된 MSGQ-ID로부터 송신처의 CPU-ID를 취득하고, 취득한 CPUID를 송신처 CPU 번호로 한다.

오퍼레이션 코드에는 액세스 요구의 내용을 나타내는 4비트의 정보가 저장된다. 송신원 CPU 번호에는 송신원의 CPU, 즉 CPU(12)를 나타내는 8비트의 ID가 저장된다. 또한, 엔트리 ID에는, 리퀘스트원의 프로세스를 일의로 나타내는 8비트의 엔트리 ID가 저장된다. 또한, MSGQ-ID에는 MSGQ-ID 레지스터(62)에 저장된 MSGQ-ID가 저장되고, 데이터에는 MSGQ-ID의 M 사이즈의 값에 따른 사이즈의 메시지가 저장되는 것으로 한다. 또한, 송신 패킷 생성부(64)는, 32바이트 또는 64바이트의 메시지가 저장된 패킷을 발행한 경우, 패킷의 엔트리 ID를 기억한다.

도 9로 돌아가, 셀렉터(65)는, 코어(40)가 응답 스테이터스 레지스터(66)에 기억된 정보를 판독하는 경우에는, 레지스터 R/W 버스(54)와 응답 스테이터스 레지스터(66)를 접속한다. 또한, 셀렉터(65)는 로컬 XB(16)를 통해 CPU(12) 이외의 CPU로부터 도 14에 도시한 포맷의 패킷을 응답으로서 수신한다.

도 14는 응답의 패킷 포맷의 일례를 설명하기 위한 도면이다. 도 14에 도시한 바와 같이, 응답의 패킷에는 스테이터스로서 메시지를 정상적으로 수신했는지 여부를 나타내는 2비트의 정보가 저장되어 있다. 셀렉터(65)는, 응답을 수신하면, 엔트리 ID를 이용하여 수신한 응답이 송신 패킷 생성부(64)가 송신한 패킷에 대한 응답인지 여부를 판별한다. 그리고, 셀렉터(65)는, 송신 패킷 생성부(64)가 송신한 패킷에 대한 응답이라고 판별한 경우에는, 수신한 응답으로부터 스테이터스를 추출하고, 추출한 스테이터스를 응답 스테이터스 레지스터(66)에 저장한다.

리드 데이터 셀렉터(67)는, 레지스터 R/W 버스(54)를 통해 코어(40)가 발행한 리드 요구의 대상이 되는 어드레스에 따라, 메시지 데이터 레지스터(61), MSGQ-ID 레지스터(62), 응답 스테이터스 레지스터(66)에 저장된 데이터를 출력한다.

응답 수신 플래그 레지스터(68)는, 셀렉터(65)가 응답을 수신함과 동시에, 응답을 수신했다는 취지를 나타내는 플래그 "1"이 저장된다. 그리고, 응답 수신 플래그 레지스터(68)는, 플래그 "1"이 저장되면, 코어(40)에 대해 리퀘스트의 송신이 완료되었다는 취지를 나타내는 신호를 송신한다. 즉, 코어(40)가 실행하는 프로세스는, 응답 수신 플래그 레지스터(68)에 플래그 "1"이 저장되어야 비로소 메시지의 송신이 수행되었다고 판별한다.

여기서, 코어(40)는 메시지를 송신하고나서 응답을 수신할 때까지의 기간 동안에 프로세스의 동작을 대기한다. 즉, 발행 요구 플래그 레지스터(63)에 "1"이 저장되고나서 응답 수신 플래그 레지스터(68)에 "1"이 저장되어 코어에 대해 리퀘스트 완료 통지를 송신할 때까지의 동안에, 코어에서 실행되는 프로그램의 진행을 정지시킨다. 이에 따라, 코어(40)는 메시지의 송신시에 컨텍스트 스위치가 발생했다고 해도, 프로세스에 대해 하나의 단계에서 메시지의 송신이 수행된 것처럼 보일 수 있다.

셀렉터(69)는 각 제어 자원(60 내지 60c)이 취득하는 패킷을 취득하면, 취득한 패킷을 로컬 XB(16)에 출력하고, 송신처가 되는 CPU에 패킷을 송신시킨다. 또한, 리드 데이터 셀렉터(70)는, 각 코어(40 내지 40b)의 리드 요구에 따라 각 제어 자원(60 내지 60c)의 레지스터로부터 판독된 데이터를, 레지스터 R/W 버스(54)를 통해 각 코어(40 내지 40b)에 송신한다.

다음, 도 15를 이용하여 수신 제어부(58)의 기능 구성에 대해 설명한다. 도 15는 실시예 1에 따른 수신 제어부의 기능 구성을 설명하기 위한 도면이다. 도 15에 도시한 예에서는, 수신 제어부(58)는 패킷 수신부(71), 메모리 리퀘스트 제어부(74), RAM(Random Access Memory) 주변부(78), 커맨드 실행부(89)를 갖는다.

또한, 패킷 수신부(71)는 리퀘스트 큐(72), 실행 레지스터(73)를 갖는다. 또한, 메모리 리퀘스트 제어부(74)는, 메모리 리퀘스트 생성부(75), 메모리 리퀘스트 레지스터(76), 라이트 데이터 레지스터(77)를 갖는다. 또한, RAM 주변부(78)는 RAM 어드레스 선택 회로(79), 라이트 데이터 생성부(80), RAM(81), 임시 레지스터군(82)을 갖는다.

또한, 일시 레지스터군(82)은, BADRS(베이스 어드레스) 레지스터(83), MKEY(메모리 키) 레지스터(84), WDP(라이트 포인터) 레지스터(85), RDP(리드 포인터) 레지스터(86)를 갖는다. 또한, 일시 레지스터군(82)은, Q 사이즈/M 사이즈 레지스터(87), INTMASK(인터럽트 마스크) 레지스터(88)를 갖는다. 또한, 커맨드 실행부(89)는, 불일치 검사부(90), 일치 검사부(91), 가산치 생성부(92), 가산기(93), 응답 패킷 생성부(94), 응답 커맨드 레지스터(95), 인터럽트 생성 회로(96)를 갖는다.

먼저, 수신 제어부(58)가 갖는 RAM 주변부(78)에 대해 설명한다. 이하의 설명에서는, RAM(81) 및 일시 레지스터군(82)에 대해 설명하고, 그 후 RAM 주변부(78)가 갖는 각 부분에 대해 설명한다.

RAM(81)은 일시 레지스터군(82)에 저장되는 각 정보를 대응시킨 엔트리를 복수 개 기억한다. 즉, RAM(81)은 복수 개의 레지스터 세트를 기억한다. 또한, RAM(81)의 기억 영역에는 어드레스가 부여되어 있으며, 각 코어(40 내지 40b)가 RAM(81)의 어드레스와 라이트 요구 및 리드 요구를 발행함으로써 RAM(81)이 기억하는 값의 조작이나 판독을 수행할 수 있다.

구체적으로는, RAM(81)은 각 레지스터(83 내지 88)에 저장되는 정보를 대응시킨 엔트리를 복수 개 기억한다. 이하, 도 16을 이용하여 RAM(81)이 기억하는 각 엔트리에 저장되는 정보에 대해 설명한다. 도 16은 RAM의 필드의 일례를 설명하기 위한 도면이다. 도 16에 도시한 예에서는, RAM(81)은 82비트의 엔트리를 갖는다. 구체적으로 설명하면, RAM(81)은 엔트리의 81번째 비트부터 79번째 비트에 Q 사이즈를 유지하고, 78번째 비트에 M 사이즈를 유지하고, 77번째 비트에 INTMASK를 유지한다.

또한, RAM(81)은 엔트리의 76번째 비트부터 36번째 비트에 베이스 어드레스의 47번째 비트부터 7번째 비트까지를 유지하고, 34번째 비트부터 24번째 비트에 메모리 키를 유지한다. 또한, RAM(81)은 엔트리의 23번째 비트부터 16번째 비트에 라이트 포인터를 유지하고, 엔트리의 15번째 비트부터 8번째 비트에 리드 포인터를 유지하고, 엔트리의 7번째 비트부터 0번째 비트에 체크 비트를 유지한다.

여기서, 도 17을 이용하여 RAM(81)의 각 엔트리에 저장되는 정보의 내용에 대해 설명한다. 도 17은 RAM의 필드에 저장되는 데이터의 내용을 설명하기 위한 도면이다. Q 사이즈란, 수신한 메시지를 저장하는 기억 영역인 메시지 기억 영역의 사이즈를 나타내는 정보이다. 또한, Q 사이즈는, 값이 "000"인 경우에는 그 엔트리가 무효라는 취지를 나타내고, 값이 "001"인 경우에는 메시지 기억 영역의 사이즈가 128바이트인 취지를 나타낸다. 또한, Q 사이즈는, 값이 "010"인 경우에는 메시지 기억 영역의 사이즈가 256바이트인 취지를 나타내고, 값이 "011"인 경우에는 메시지 기억 영역의 사이즈가 "512"바이트인 취지를 나타낸다.

또한, Q 사이즈는, 값이 "100"인 경우에는 메시지 기억 영역의 사이즈가 1킬로바이트인 취지를 나타내고, 값이 "101"인 경우에는 메시지 기억 영역의 사이즈가 2킬로바이트인 취지를 나타낸다. 또한, Q 사이즈는, 값이 "110"인 경우에는 메시지 기억 영역의 사이즈가 4킬로바이트인 취지를 나타내고, 값이 "111"인 경우에는 메시지 기억 영역의 사이즈가 8킬로바이트인 취지를 나타낸다.

M 사이즈란, 메시지의 사이즈를 나타내는 정보로서, 값이 "0"일 때에는 메시지의 사이즈가 32바이트이고, 값이 "1"일 때에는 메시지의 사이즈가 64바이트인 것을 나타낸다. INTMASK란, 메시지 수신시에 인터럽트를 발생시키는지 여부를 지시하는 정보이다. 또한, INTMASK는, 값이 "0"인 경우에는 인터럽트를 발생시키지 않는 취지를 나타내고, 값이 "1"인 경우에는 인터럽트를 발생시키는 취지를 나타낸다.

베이스 어드레스란, 메시지를 저장하는 기억 영역인 메시지 기억 영역의 기준이 되는 41비트의 어드레스 정보이다. 또한, 베이스 어드레스는, 리드 포인터와 라이트 포인터를 합하여 메시지 기억 영역의 어드레스를 나타내고, 메시지 기억 영역의 사이즈에 따라 데이터 사이즈가 변화된다. 또한, 메시지 기억 영역은 후술하는 가산치가 나타내는 영역 사이즈와 일치한 어드레스 바운더리부터 시작하게 된다.

메모리 키란, 메시지 기억 영역에 대한 액세스를 허가하는지 여부를 판별하기 위한 키 정보로서, 즉, 메시지 기억 영역 보호를 위한 메모리 키의 값이다. 또한, 라이트 포인터란, 메시지 기억 영역에 메시지를 기입할 때의 기입 시작 어드레스를 나타내는 8비트의 어드레스이다. 또한, 리드 포인터란, 메시지 기억 영역으로부터 메시지를 판독할 때의 판독 시작 어드레스를 나타내는 8비트의 어드레스이다.

또한, 라이트 포인터의 값 및 리드 포인터의 값은 메시지 기억 영역의 사이즈에 따라 데이터 사이즈가 변화된다. 또한, 체크 비트란, 동일 엔트리 내에 포함되는 각 정보로부터 에러의 검출 및 정정을 수행하기 위한 용장 비트로서, ECC(Error Detection and Correction)용의 비트이다.

다음, 일시 레지스터군(82)이 갖는 각 레지스터(83 내지 88)에 대해 설명한다. 각 레지스터(83 내지 88)는 RAM(81)이 기억하는 각 엔트리에 포함되는 정보를 일시적으로 유지하는 레지스터이다. 구체적으로는, 각 레지스터(83 내지 88)에는, 코어(40)가 실행하는 프로세스에서 보았을 때 각각 어드레스가 부여되어 있다. 그리고, 코어(40)가 실행하는 프로세스는, 어드레스를 지정함으로써 각 레지스터(83 내지 88)에 저장되는 정보의 써내기나 판독을 수행할 수 있다.

여기서, 도 18을 이용하여 임시 레지스터군(82)의 각 레지스터(83 내지 88)에 부여되는 어드레스의 일례에 대해 설명한다. 도 18은 소프트웨어에서 본 수신 제어부의 레지스터의 어드레스의 일례를 설명하기 위한 도면이다. 또한, 도 18에 도시한 예에서는, 각 레지스터에 부여되는 어드레스와, 각 레지스터에 대해 발행 가능한 커맨드, 각 레지스터(83 내지 88)에 저장하는 데이터의 사이즈에 대해 기재했다. 또한, 도 18에 도시한 예에서는, Q 사이즈/M 사이즈 레지스터(87)에 저장되는 정보를 Q 사이즈와 M 사이즈로 나누어 기재했다.

Q 사이즈/M 사이즈 레지스터(87)는 Q 사이즈와 M 사이즈가 저장되는 레지스터이다. 도 18에 도시한 예에서는, Q 사이즈/M 사이즈 레지스터(87)는, Q 사이즈를 저장하는 어드레스로서 "0x00" 내지 "0x07"이 부여되고, M 사이즈를 저장하는 어드레스로서 "0x08" 내지 "0x0F"가 부여된다. 또한, Q 사이즈/M 사이즈 레지스터(87)는, 라이트 요구와 리드 요구의 대상이 되는 레지스터로서, 3비트의 Q 사이즈와 1비트의 M 사이즈가 저장된다.

INTMASK 레지스터(88)는 INTMASK가 저장되는 레지스터이다. 도 18에 도시한 예에서는, INTMASK 레지스터(88)에는 INTMASK를 저장하는 어드레스로서 "0x10" 내지 "0x17"이 부여되고, 라이트 요구와 리드 요구의 대상이 되는 레지스터이다.

BADRS 레지스터(83)는 베이스 어드레스가 저장되는 레지스터이다. 도 18에 도시한 예에서는, BADRS 레지스터(83)에는 베이스 어드레스를 저장하는 어드레스로서 "0x18" 내지 "0x1F"가 부여되고, 라이트 요구와 리드 요구의 대상이 되는 레지스터이다. MKEY 레지스터(84)는 메모리 키가 저장되는 레지스터이다. 도 18에 도시한 예에서는, MKEY 레지스터(84)는 메모리 키 값을 저장하는 어드레스로서 "0x20" 내지 "0x27"이 부여되고, 라이트 요구와 리드 요구의 대상이 되는 레지스터이다.

또한, WDP 레지스터(85)는 라이트 포인터가 저장되는 레지스터이다. 도 18에 도시한 예에서는, WDP 레지스터(85)는 라이트 포인터를 저장하는 어드레스로서 "0x28" 내지 "0x2F"가 부여되고, 라이트 요구와 리드 요구의 대상이 되는 레지스터이다. 또한, RDP 레지스터(86)는 리드 포인터가 저장되는 레지스터이다. 도 18에 도시한 예에서는, RDP 레지스터(86)는 리드 포인터를 저장하는 어드레스로서 "0x30" 내지 "0x37"이 부여되고, 라이트 요구와 리드 요구의 대상이 되는 레지스터이다.

또한, 도 18 중의 업데이트 레지스터란, 메시지를 판독할 때에 리드 포인터의 값을 갱신하는 처리를 프로세스로부터 지시하기 위한 가상적인 레지스터이다. 즉, 업데이트 레지스터에 대한 라이트 요구가 발행된 경우에는, 라이트 데이터의 입력은 수행되지 않고, 갱신된 리드 포인터의 값만이 기입되게 된다. 도 18에 도시한 예에서는, 업데이트 레지스터는 가산치를 저장하는 어드레스로서 "0x38" 내지 "0x3F"가 부여된다.

또한, 도 18에 도시된 각 레지스터는, 도 10에 도시한 각 레지스터와 동일하게, 소프트웨어로부터 액세스가 수행되기 쉽도록 데이터의 유효 길이가 8바이트(64비트) 이내라 하더라도, 8바이트 바운더리에 맞추어진 어드레스 영역을 점유한다. 또한, 도 18에 도시된 각 레지스터는, 점유하는 어드레스 영역에 있어서 데이터의 유효 길이 이외의 부분의 값은 의미를 갖지 않는 것으로 한다.

다음, 도 15로 돌아가, RAM 어드레스 선택 회로(79)에 대해 설명한다. RAM 어드레스 선택 회로(79)는 레지스터 R/W 버스(54)를 통해 코어(40)로부터 레지스터 어드레스와 커맨드를 취득한다. 그러면, RAM 어드레스 선택 회로(79)는 수신한 레지스터 어드레스의 상위 어드레스를 이용하여, RAM(81)이 기억하는 엔트리 중 액세스 대상이 되는 엔트리를 선택한다.

그리고, RAM 어드레스 선택 회로(79)는 수신한 레지스터 어드레스의 하위 어드레스를 이용하여 액세스 대상이 되는 기억 영역을 식별한다. 그 후, RAM 어드레스 선택 회로(79)는 수신한 커맨드에 따라, 식별한 기억 영역의 판독이나 기입을 실행한다. 또한, RAM 어드레스 선택 회로(79)는 패킷 수신부로부터 레지스터 ID를 수신하면, 수신한 레지스터 ID가 나타내는 엔트리의 각 정보 중 체크 비트 이외의 정보를 일시 레지스터군(82)의 각 레지스터(83 내지 88)에 저장한다. 즉, RAM 어드레스 선택 회로(79)는 레지스터 ID가 나타내는 레지스터 세트의 값을 일시 레지스터군(82)의 각 레지스터(83 내지 88)에 저장한다.

여기서, 코어(40)가 실행하는 프로세스에서 보았을 때에, 일시 레지스터군(82)에 부여되어 있는 것처럼 보이는 어드레스는 실제로는 RAM(81)의 하위 어드레스이다. 즉, 코어(40)가 실행하는 프로세스는 RAM(81)이 기억하는 각 엔트리를 각각 상이한 레지스터군이 기억하도록 인식한다. 그리고, 코어(40)가 실행하는 프로세스는, 레지스터군을 선택하기 위한 상태 어드레스, 즉 RAM(81)이 기억하는 엔트리를 선택하기 위한 상위 어드레스에, 각 레지스터에 부여되는 어드레스를 하위 어드레스로서 부가한 레지스터 어드레스를 생성한다.

그 후, 코어(40)가 실행하는 프로세스는, 생성한 레지스터 어드레스를 수신 제어부(58)에 출력함으로써, 마치 RAM(81)이 기억하는 각 정보가 각각 상이한 레지스터에 저장되어 있는 것처럼, 액세스 대상이 되는 RAM(81) 상의 정보를 선택한다.

라이트 데이터 생성부(80)는, 레지스터 R/W 버스(54)를 통해 코어(40)로부터 라이트 데이터를 취득하면, RAM 어드레스 선택 회로(79)가 선택한 기억 영역에, 코어(40)로부터 취득한 데이터를 저장한다. 또한, 라이트 데이터 생성부(80)는 후술하는 가산기(93)가 생성한 새로운 라이트 포인터나 리드 포인터를 RAM(81)에 저장한다.

또한, 코어(40)가 발행한 커맨드가 RAM(81)에의 라이트인 경우에는, RAM 주변부(78)는 이하의 처리를 실행하게 된다. 즉, RAM 주변부(78)는, 레지스터 어드레스의 상위 어드레스가 나타내는 엔트리 중 하위 어드레스가 나타내는 정보에 대해 데이터의 재기록을 수행하고, 라이트 데이터에 대한 용장 비트를 계산하고, 새로운 체크 비트를 저장한다.

또한, RAM(81)이 기억하는 정보의 판독이 수행되는 경우에는, 판독된 리드 데이터가 레지스터 R/W 버스(54)를 통해 코어(40)에 송신되고, 판독된 데이터를 라이트 데이터 생성부(80)가 수신한다. 그리고, 라이트 데이터 생성부(80)는 수신한 데이터를 다시 RAM(81)에 기입하게 된다.

다음, 수신 제어부(58)가 갖는 패킷 수신부(71), 메모리 리퀘스트 제어부(74), 커맨드 실행부(89)가 실행하는 처리에 대해 설명한다. 패킷 수신부(71)는, 로컬 XB(16)를 통해 다른 CPU가 송신한 패킷을 수신하면, 수신한 패킷을 리퀘스트 큐(72)에 저장한다. 또한, 패킷 수신부(71)는 RAM(81)의 갱신 타이밍과 동기하여 리퀘스트 큐(72)의 선두로부터 하나의 패킷을 취출하고, 취출된 패킷을 실행 레지스터(73)에 저장한다.

그리고, 패킷 수신부(71)는 실행 레지스터(73)에 저장한 패킷으로부터 MSGQ-ID를 추출하고, 추출한 MSGQ-ID로부터 레지스터 ID를 취득한다. 그 후, 패킷 수신부(71)는 취득한 레지스터 ID를 RAM 주변부(78)의 RAM 어드레스 선택 회로(79)에 출력함으로써, 레지스터 ID가 나타내는 레지스터 세트의 값을 일시 레지스터군(82)의 각 레지스터(83 내지 88)에 저장한다. 또한, 패킷 수신부(71)는, 실행 레지스터(73)에 저장한 패킷으로부터 데이터, 즉 메시지를 추출하여, 추출한 메시지를 메모리 리퀘스트 제어부(74)가 갖는 라이트 데이터 레지스터(77)에 저장한다.

다음, 패킷 수신부(71)는, 추출한 MSGQ-ID로부터 액세스 키 값을 취득하고, 취득한 액세스 키 값을 커맨드 실행부(89)의 불일치 검사부(90)에 출력한다. 그러면, 불일치 검사부(90)는 MKEY 레지스터(84)에 저장된 메모리 키의 값과, 패킷 수신부(71)로부터 수신한 액세스 키 값이 일치하는지 여부를 판별한다. 그리고, 불일치 검사부(90)는 메모리 키의 값과 액세스 키 값이 일치하는 경우에는, 액세스를 허가한다는 취지를 메모리 리퀘스트 생성부(75), 응답 패킷 생성부(94), 인터럽트 생성 회로(96)에 통지한다. 한편, 불일치 검사부(90)는 메모리 키의 값과 액세스 키 값이 일치하지 않는 경우에는, 액세스를 허가하지 않다는 취지를 메모리 리퀘스트 생성부(75), 응답 패킷 생성부(94), 인터럽트 생성 회로(96)에 통지한다.

또한, 전술한 불일치 검사부(90)의 처리와 동시에, 일치 검사부(91), 가산치 생성부(92), 가산기(93)가 이하의 처리를 실행한다. 먼저, 가산치 생성부(92)는 Q 사이즈/M 사이즈 레지스터(87)에 저장된 M 사이즈의 값에 따라 가산치를 생성한다. 또한, 가산기(93)는 RDP 레지스터(86)에 저장된 라이트 포인터의 값에 가산치 생성부(92)가 생성한 가산치를 가산함으로써, 라이트 포인터의 갱신치를 산출한다.

그리고, 일치 검사부(91)는 가산기(93)에 의해 산출된 라이트 포인터의 갱신치와, RDP 레지스터(86)에 저장된 리드 포인터의 값이 일치하는지 여부를 판별한다. 또한, 일치 검사부(91)는 라이트 포인터의 갱신치와 리드 포인터의 값이 일치한다고 판별한 경우에는, 오버플로우가 발생했다고 판별한다. 그리고, 일치 검사부(91)는 오버플로우가 발생했다는 취지를, 메모리 리퀘스트 생성부(75), 응답 패킷 생성부(94), 인터럽트 생성 회로(96)에 출력한다.

한편, 일치 검사부(91)는 라이트 포인터의 갱신치와 리드 포인터의 값이 일치하지 않는다고 판별한 경우에는, 메모리에의 기입을 허가한다는 취지를 메모리 리퀘스트 생성부(75), 응답 패킷 생성부(94), 인터럽트 생성 회로(96)에 출력한다.

여기서, 메모리 리퀘스트 제어부(74)의 메모리 리퀘스트 생성부(75)는 불일치 검사부(90)로부터 액세스를 허가한다는 취지의 통지를 취득하고, 일치 검사부(91)로부터 메모리에의 기입을 허가한다는 취지를 취득한 경우에는, 이하의 처리를 실행한다. 즉, 메모리 리퀘스트 생성부(75)는, BADRS 레지스터(83)에 저장된 베이스 어드레스의 값과, WDP 레지스터(85)에 저장된 라이트 어드레스의 값과, Q 사이즈/M 사이즈 레지스터(87)에 저장된 Q 사이즈의 값과 M 사이즈의 값을 취득한다.

그리고, 메모리 리퀘스트 생성부(75)는, 취득한 베이스 어드레스의 값, 라이트 어드레스의 값, Q 사이즈의 값 및 M 사이즈의 값을 이용하여, 메모리 라이트 어드레스를 생성하고, 생성한 메모리 라이트 어드레스를 메모리 리퀘스트 레지스터(76)에 저장한다. 그러면, 메모리 리퀘스트 제어부(74)는, 메모리 리퀘스트 레지스터(76)에 저장된 메모리 라이트 어드레스와, 라이트 데이터 레지스터(77)에 저장된 메시지를 메모리 R/W 버스(53)에 출력함으로서, 메시지를 메모리(17, 18)에 저장한다.

또한, 메모리 리퀘스트 생성부(75)는 불일치 검사부(90)로부터 액세스를 허가하지 않는다는 취지의 통지를 취득한 경우나, 일치 검사부(91)로부터 오버플로우가 발생했다는 취지의 통지를 취득한 경우에는, 메모리 리퀘스트의 생성을 수행하지 않고 처리를 종료한다. 이러한 경우에는, 패킷 수신부(71)는, 실행 레지스터(73)에 저장된 패킷을 파기하고, 리퀘스트 큐(72)로부터 새로운 패킷을 취출하여, 실행 레지스터(73)에 저장한다.

여기서, 도 19를 이용하여 메모리 리퀘스트 생성부(75)가 생성하는 메모리 라이트 어드레스의 일례에 대해 설명한다. 도 19는 메모리 라이트 어드레스의 일례를 설명하기 위한 도면이다. 예컨대, 도 19에 도시한 예에서는, 메모리 리퀘스트 생성부(75)는 Q 사이즈의 코드치가 "001"이고, M 사이즈의 값이 "0"인 경우에는, 이하의 메모리 라이트 어드레스를 생성한다. 즉, 메모리 리퀘스트 생성부(75)는 베이스 어드레스의 47번째 비트부터 7번째 비트와 라이트 어드레스의 0번째 비트와 "0b000000"을 연결한 48비트의 메모리 라이트 어드레스를 생성한다.

또한, 예컨대, 메모리 리퀘스트 생성부(75)는, Q 사이즈의 코드치가 "001"이고, M 사이즈의 값이 "1"인 경우에는 이하의 메모리 라이트 어드레스를 생성한다. 즉, 메모리 리퀘스트 생성부(75)는 베이스 어드레스의 47번째 비트부터 7번째 비트와 라이트 어드레스의 1번째 비트부터 0번째 비트와 "0b00000"을 연결한 48비트의 메모리 라이트 어드레스를 생성한다.

또한, 예컨대, 메모리 리퀘스트 생성부(75)는 Q 사이즈의 코드치가 "010"이고, M 사이즈의 값이 "0"인 경우에는, 이하의 메모리 라이트 어드레스를 생성한다. 즉, 메모리 리퀘스트 생성부(75)는, 베이스 어드레스의 47번째 비트부터 8번째 비트와 라이트 어드레스의 1번째 비트부터 0번째 비트와 "0b000000"을 연결한 48비트의 메모리 라이트 어드레스를 생성한다.

또한, 예컨대, 메모리 리퀘스트 생성부(75)는 Q 사이즈의 코드치가 "010"이고, M 사이즈의 값이 "1"인 경우에는, 이하의 메모리 라이트 어드레스를 생성한다. 즉, 메모리 리퀘스트 생성부(75)는, 베이스 어드레스의 47번째 비트부터 8번째 비트와 라이트 어드레스의 2번째 비트부터 0번째 비트와 "0b00000"을 연결한 48비트의 메모리 라이트 어드레스를 생성한다.

즉, 메모리 리퀘스트 생성부(75)는, 도 19에 도시한 바와 같이, Q 사이즈의 코드치가 증가함에 따라, 메모리 라이트 어드레스로서 사용할 베이스 어드레스의 비트수를 적게 한다. 또한, 메모리 리퀘스트 생성부(75)는, Q 사이즈의 코드치가 증가함에 따라, 메모리 라이트 어드레스로서 사용할 라이트 포인터의 비트수를 증가시킨다.

도 15로 돌아가, 응답 패킷 생성부(94)는, 도 14에 도시한 응답을 생성하고, 불일치 검사부(90) 및 일치 검사부(91)의 처리 결과에 따른 스테이터스를 응답으로 저장한다. 여기서, 응답 패킷 생성부(94)는, 송신처 CPU 번호에 메시지 송신원의 CPU를 나타내는 CPU 번호를 저장한다.

그리고, 응답 패킷 생성부(94)는 생성한 응답을 응답 커맨드 레지스터(95)에 저장한다. 예컨대, 응답 패킷 생성부(94)는 불일치 검사부(90)로부터 액세스를 허가한다는 취지의 통지를 취득하고, 일치 검사부(91)로부터 메모리에의 기입을 허가한다는 취지의 통지를 취득한 경우에는, 이하의 스테이터스를 저장한다. 즉, 응답 패킷 생성부(94)는 OVFL 비트를 "0"으로 하고, PROT 비트를 "0"으로 함으로써, 정상적으로 메시지를 수신했다는 취지를 나타내는 스테이터스를 저장한다.

한편, 응답 패킷 생성부(94)는 불일치 검사부(90)로부터 액세스를 허가하지 않는다는 취지의 통지를 취득한 경우에는, PROT 비트를 "1"로 한다. 또한, 응답 패킷 생성부(94)는, 일치 검사부(91)로부터 오버플로우가 발생했다는 취지의 통지를 취득한 경우에는, OVFL 비트를 "1"로 한다. 또한, 스테이터스의 각 비트는 송신처의 CPU가 갖는 응답 스테이터스 레지스터에 저장된 후, 송신처의 CPU가 실행하는 프로세스에 의해 판독된다. 또한, 응답 커맨드 레지스터(95)는, 응답 패킷 생성부(94)로부터 응답을 취득하면, 취득한 응답을 일시적으로 유지하고, 그 후, 로컬 XB(16)를 통해 메시지 송신원의 CPU로 송신한다.

인터럽트 생성 회로(96)는 불일치 검사부(90)로부터 액세스를 허가한다는 취지의 통지를 취득하고, 또한 일치 검사부(91)로부터 메모리에의 기입을 허가한다는 취지의 통지를 취득한 경우에는, 이하의 처리를 실행한다. 먼저, 인터럽트 생성 회로(96)는 INTMASK 레지스터(88)에 저장된 INTMASK의 값이 "1"인지 "0"인지 판별한다. 그리고, 인터럽트 생성 회로(96)는, INTMASK의 값이 "1"인 경우에는, 레지스터 R/W 버스(54)를 통해 코어(40 내지 40b)에 대해 인터럽트 처리의 실행을 요구하는 인터럽트 요구 신호를 출력한다.

한편, 인터럽트 생성 회로(96)는 INTMASK의 값이 "0"인 경우에는 인터럽트 요구 신호를 출력하지 않는다. 또한, 인터럽트 생성 회로(96)는, 불일치 검사부(90)로부터 액세스를 허가하지 않는다는 취지의 통지를 취득한 경우나, 일치 검사부(91)로부터 오버플로우가 발생했다는 취지의 통지를 취득한 경우에는, 인터럽트 요구 신호를 출력하지 않는다.

여기서, 인터럽트 요구 신호가 출력된 경우에는, 각 코어(40 내지 40b)는 컨텍스트 스위치에 의해 메시지의 수신을 대기하던 프로세스를 실행한다. 그리고, 코어(40 내지 40b)는 메시지 송신원의 CPU가 실행하는 프로세스에 통지한 레지스터 ID가 나타내는 레지스터 세트를 이용하여 메모리(18, 19)에 저장된 메시지의 판독을 수행한다.

또한, RAM 주변부(78)는, RAM(81)이 기억하는 엔트리의 초기화, 인터럽트 마스크의 변경, 메시지 기입 동작, 메시지 판독 조작을 수행하는 경우에는 도 20에 도시한 동작에 따라 RAM(81)에 기억된 정보의 갱신을 수행한다. 도 20은 동작 종류별로 RAM의 필드의 갱신 부분을 설명하기 위한 도면이다.

예컨대, RAM 주변부(78)는, 코어(40)가 각 레지스터(83 내지 88)에 대한 리드 요구나 라이트 요구에 의해 엔트리의 초기화를 수행하는 경우에는, 각 필드의 값을 이하와 같이 갱신한다. 먼저, RAM 주변부(78)는 Q 사이즈, M 사이즈, 베이스 어드레스, 메모리 키의 값을 프로세스가 지정한 값으로 갱신한다. 또한, RAM 주변부(78)는, INTMASK의 값을 "0"으로 갱신하고, 라이트 포인터와 리드 포인터의 값을 "All0"으로 갱신한다. 또한, RAM 주변부(78)는, 체크 비트의 값을 갱신 후의 각 정보에 따라 생성되는 값으로 갱신한다.

또한, RAM 주변부(78)는 코어(40)가 인터럽트 마스크의 변경을 수행하는 경우에는, Q 사이즈, M 사이즈, 베이스 어드레스, 메모리 키, 라이트 포인터, 리드 포인터의 값을 변경하지 않고, INTMASK의 값을 프로세스가 지정한 값으로 갱신한다. 또한, RAM 주변부(78)는, 메시지를 수신하고, 메시지를 메모리(18, 19)에 기입하는 경우에는, 라이트 포인터의 값만을 갱신한다. 또한, RAM 주변부(78)는 코어(40)가 메시지를 메모리(18, 19)로부터 판독하는 경우에는, 리드 포인터의 값만을 갱신한다.

또한, 전술한 수신 제어부(58)는 복수 개의 레지스터 세트를 RAM(81) 내에 유지하는 것으로 했지만, 실시예는 이에 한정되지 않으며, 예컨대, FF(Flip Flop) 등을 이용하여 각 레지스터 세트를 유지해도 된다. 또한, 수신 제어부(58)는, RAM(81)으로부터 판독된 레지스터 세트를 일시 레지스터군(82)에 저장함으로써 RAM(81)으로부터의 판독에서의 지연 시간을 고려한 것인데, 실시예는 이에 한정되지 않는다. 즉, 수신 제어부(58)는, 복수 개의 레지스터 세트를 기억하고, 수신한 레지스터 ID가 나타내는 레지스터 세트에 따라, 메시지를 메모리(18, 19)에 저장할 수 있으면, 다른 구성을 갖는 것으로 할 수도 있다.

다음, 도 21을 이용하여 드라이버(33)가 메모리(18, 19) 상에 확보하는 메시지 기억 영역과, 각 어드레스 포인터의 유효 비트 길이에 대해 설명한다. 도 21은 메시지 기억 영역을 설명하기 위한 도면이다. 예컨대, RAM(81)은, 하드웨어의 저비용화를 목적으로 하여 라이트 포인터와 리드 포인터로서 사용되는 물리 어드레스 중 일부의 비트만을 유지한다. 따라서, 드라이버(33)는 도 21에 도시한 바와 같이, Q 사이즈와 M 사이즈에 따라, 메시지 기억 영역을 확보한다.

예컨대, 드라이버(33)는 Q 사이즈가 "001"이고, M 사이즈가 "1"인 경우에는, 메시지 기억 영역의 사이즈를 128바이트로 하고, 64바이트의 메시지를 1건 기억할 수 있도록 한다. 이 때, 베이스 어드레스의 유효 비트 길이는 베이스 어드레스의 47번째 비트부터 7번째 비트까지가 되고, 라이트 포인터 및 리드 포인터의 유효 비트 길이가 0번째 비트로만 된다.

또한, 드라이버(33)는 Q 사이즈가 "001"이고, M 사이즈가 "0"인 경우에는 메시지 기억 영역의 사이즈를 128바이트로 하고, 32바이트의 메시지를 3건 기억할 수 있도록 한다. 이 때, 베이스 어드레스의 유효 비트 길이는, 베이스 어드레스의 47번째 비트부터 7번째 비트까지가 되고, 라이트 포인터 및 리드 포인터의 유효 비트 길이는 1번째 비트부터 0번째 비트까지가 된다.

또한, 드라이버(33)는 Q 사이즈가 "010"이고, M 사이즈가 "1"인 경우에는 메시지 기억 영역의 사이즈를 256바이트로 하고, 64바이트의 메시지를 3건 기억할 수 있도록 한다. 이 때, 베이스 어드레스의 유효 비트 길이는 베이스 어드레스의 47번째 비트부터 8번째 비트까지가 되고, 라이트 포인터 및 리드 포인터의 유효 비트 길이는 1번째 비트부터 0번째 비트까지가 된다.

이하, 드라이버(33)는 Q 사이즈와 M 사이즈의 값에 따라 도 21에 도시한 사이즈의 메시지 기억 영역을 설정한다. 즉, 드라이버(33)는 2의 멱승으로 표시되는 넓이의 연속된 물리 어드레스를 메시지 기억 영역용으로 확보한다. 또한, 드라이버(33)는 Q 사이즈의 값이 늘어남에 따라, 지수 함수적으로 넓은 메시지 기억 영역을 설정한다.

여기서, M 사이즈는 메시지의 크기를 나타내는 정보이기 때문에, Q 사이즈와 M 사이즈의 값에 따라 메시지 기억 영역에 저장되는 메시지 기억 건수가 변화된다. 이 결과, 베이스 어드레스의 유효 비트 길이는 메시지 기억 영역이 넓어짐에 따라 짧아지며, 라이트 포인터와 리드 포인터의 유효 비트 길이는 메시지 기억 건수가 많아짐에 따라 길어진다. 또한, 수신 제어부(58)는 가산기(93)와 일치 검사부(91)를 이용하여 오버플로우를 검출하므로, 메시지 기억 건수는 메시지 기억 영역의 사이즈를 메시지 사이즈로 나눈 수에서 1을 뺀 값이 된다.

또한, CPU(12)는 메모리(18, 19) 상에 메시지를 저장하는 메시지 기억 영역을 확보한다. 그러나, 메모리(18, 19)는 OS(32)의 커넬이나 드라이버(33) 등의 관리 프로그램뿐만 아니라, 애플리케이션(35) 등의 사용자 모드로 동작하는 소프트웨어로부터도 직접 이용 가능한 자원이다. 따라서, 메모리(18, 19) 상에 확보한 메시지 기억 영역에 대해, 사용자 모드로 동작하는 소프트웨어가 액세스한 경우에는, 메시지가 재기록될 우려가 있다.

따라서, CPU(12) 내지 CPU(15)가 실행하는 프로세스는, 메모리 키와 어드레스 키 및 메시지 기억 영역에 할당하는 메모리 어드레스를 이용하여, 메시지 기억 영역에 대한 액세스를 제어하고, 메시지 통신 자원의 파괴를 방지한다. 이하, 메시지 통신 자원의 파괴를 방지하는 방법에 대해 설명한다.

먼저, 메모리 키와 어드레스 키를 이용하여, 메시지 통신 자원의 파괴를 방지하는 방법에 대해 설명한다. 먼저, 메시지 송신측의 프로세스는, 메시지 수신측의 프로세스로부터 통지받은 액세스 키의 값을 포함하는 MSGQ-ID를 생성하고, 생성한 MSGQ-ID를 메시지와 함께 메시지 수신측의 프로세스로 송신한다.

또한, 메시지 수신측의 프로세스는, MSGQ-ID에 포함되는 액세스 키의 값이 메모리 키의 값과 일치하는지 여부를 판별하고, 액세스 키와 메모리 키의 값이 일치하지 않는 경우에는 메시지의 기입이나 라이트 포인터의 갱신을 수행하지 않는다. 여기서, 메모리 키의 값은, 메시지 수신측의 프로세스가 임의로 결정하고, 메시지 송신측의 프로세스에 통지하는 것이므로 송신측의 프로세스의 미스에 의해 다른 메시지 통신 자원의 파괴를 방지할 수 있다.

다음, 도 22, 도 23을 이용하여, 메시지 기억 영역에 할당하는 메모리 어드레스를 이용하여 메시지 수신 영역의 파괴를 방지하는 방법에 대해 설명한다. 도 22는 프로그램 미스를 고려한 어드레스 맵을 설명하기 위한 도면이다. 또한, 도 23은 프로그램 미스를 고려한 어드레스 맵에서의 어드레스 구성을 설명하기 위한 도면이다.

예컨대, 드라이버(33)는, 도 22 중 (j)에 도시한 바와 같이, 도 18에 도시한 각 레지스터를 메모리 맵 상의 NC(Non-Cacheable) 영역으로부터 MMIO(Memory Mapped Input/Output) 방식으로 정의한다. 이 때, 드라이버(33)는, 도 22 중 (k)에 도시한 바와 같이, 레지스터 세트의 한 세트만큼, 즉, RAM(81)이 기억하는 하나의 엔트리만큼의 레지스터를 8킬로바이트의 물리 페이지 영역 내에 정의한다. 또한, 드라이버(33)는 다른 레지스터 세트를 상이한 8킬로바이트의 물리 페이지 영역 내에 정의한다. 여기서, 각 레지스터 세트는, 물리 어드레스 상에서만 정의되어 있으며, 가상 어드레스와의 대응지음이 수행되어 있지 않기 때문에, 사용자 모드로 동작하는 소프트웨어로부터 액세스할 수 없다.

그리고, 드라이버(33)는 사용자 프로세스 #1로부터 메시지 통신 자원의 할당을 요구받으면, 레지스터 ID를 할당하여 사용자 프로세스 #1에 MSGQ-ID를 통지한다. 이 때, 드라이버(33)는 NC 영역 상의 레지스터 ID에 대응하는 물리 페이지 어드레스를 임의의 가상 어드레스와 대응시켜 TLB(43)에 등록한다. 그리고, 드라이버(33)는 사용자 프로세스 #1에 물리 페이지 어드레스와 대응시킨 가상 어드레스를 통지한다. 그러면, 사용자 프로세스 #1은 통지된 가상 어드레스에 액세스함으로써, 통지된 MSGQ-ID에 대응한 레지스터 자원에 액세스할 수 있다.

이와 같이 사용자 프로세스 #1은, 드라이버(33)로부터 할당받은 드라이버 세트 이외의 드라이버 세트에 대해서는, 가상 어드레스가 TLB(43)에 등록되어 있지 않으므로, 액세스할 수 없다. 이 결과, 예컨대, 사용자 프로세스 #1은 잘못하여 사용자 프로세스 #2가 사용하는 메시지 통신 자원을 파괴하지 않는다. 또한, 드라이버(33)는, 메시지 기억 영역에 대해서도, 레지스터 세트와 동일한 처리를 수행함으로써 사용자 프로세스 #1이 사용자 프로세스 #2에 할당한 메시지 기억 영역에 대한 액세스를 방지할 수 있다. 따라서, 드라이버(33)는 프로그램 미스에 의한 메시지 통신 자원의 파괴를 방지할 수 있다.

또한, 예컨대, 드라이버(33)는, 도 23에 예시하는 어드레스 구성의 물리 어드레스를 각 레지스터에 대해 부여한다. 예컨대, 드라이버(33)는, NC 공간에서의 24비트의 고유 어드레스를 어드레스 비트의 47번째 비트부터 24번째 비트까지 저장한다. 또한, 드라이버(33)는 11비트의 레지스터 ID를 어드레스 비트의 23번째 비트부터 13번째 비트까지 저장한다. 또한, 드라이버(33)는, 도 18에 도시한 각 레지스터에 부여하는 13비트의 고유 어드레스를 어드레스 비트의 12번째 비트부터 0번째 비트까지 저장한다. 그리고, 드라이버(33)는 각 비트를 저장한 어드레스 비트를 각 레지스터에 부여한다.

예컨대, 송신 제어부(57), 어드레스 디코더(59), 셀렉터(65), 송신 패킷 생성부(64), 리드 데이터 셀렉터(67), 셀렉터(69), 리드 데이터 셀렉터(70)는, 전자 회로이다. 또한, RAM 어드레스 선택 회로(79), 라이트 데이터 생성부(80), 메모리 리퀘스트 생성부(75), 불일치 검사부(90), 일치 검사부(91), 가산치 생성부(92), 가산기(93), 응답 패킷 생성부(94), 인터럽트 생성 회로(96)는 전자 회로이다. 여기서, 전자 회로의 예로서 ASIC(Application Specific Integrated Circuit)이나 FPGA(Field Programmable Gate Array) 등의 집적 회로, 또는 CPU(Central Processing Unit)나 MPU(Micro Processing Unit) 등을 적용한다.

다음, 도 24를 이용하여 메시지를 송수신할 때에 메시지 송신측의 노드와 메시지 수신측 노드가 실행하는 처리의 흐름에 대해 설명한다. 도 24는 메시지를 송수신할 때의 동작을 설명하기 위한 시퀀스도이다. 또한, 도 24에 도시한 예에서는, 수신측 노드가 실행하는 사용자 프로세스 #2가 폴링을 수행함으로써, 메시지의 수신을 감시할 때의 처리의 흐름에 대해 설명한다.

먼저, 수신측 노드가 실행하는 사용자 프로세스 #2는 일시 레지스터군(82)을 감시하고(단계 S101, S103), 라이트 포인터의 값과 리드 포인터의 값을 비교함으로써, 메시지의 수신을 검지한다. 또한, 도 24에 도시한 예에서는, 단계 S102 및 단계 S104에 있어서, 메시지가 수신되어 있지 않기 때문에, 메시지의 수신은 미검지로 된다(단계 S102, S104).

여기서, 사용자 프로세스 #1은, 발행 요구 플래그 레지스터(63)에 플래그 "1"을 저장함으로써 CPU(12)에 메시지의 송신을 지시한다(단계 S105). 그러면, CPU(12)는, 메시지를 포함하는 패킷을 수신측 노드에 송신한다(단계 S106). 또한, 수신측 노드가 갖는 CPU는 수신한 메시지를 메시지 기억 영역에 저장한다(단계 S107). 이 때, 수신측 노드가 갖는 CPU는 라이트 포인터의 값을 갱신한다. 또한, 수신측 노드가 갖는 CPU는 완료 응답을 CPU(12)에 송신한다(단계 S108).

그러면, CPU(12)는, 응답 수신 플래그 레지스터(68)에 플래그 "1"을 저장함으로써 사용자 프로세스 #1에 메시지의 송신이 완료되었다는 취지를 통지한다. 그리고, 사용자 프로세스 #1은 응답 스테이터스 레지스터(66)의 값의 판독을 수행다(단계 S109).

한편, 사용자 프로세스 #2는 일시 레지스터군(82)을 감시하고(단계 S110), 라이트 포인터의 값과 리드 포인터의 값을 비교한다. 그러면, 사용자 프로세스 #2는 라이트 포인터의 값과 리드 포인터의 값이 상이하기 때문에, 메시지를 검지한다(단계 S111). 그리고, 사용자 프로세스 #2는 메시지의 판독을 실행하고(단계 S112), 처리를 종료한다.

다음, 도 25를 이용하여, 메시지를 수신한 메시지 수신측의 노드가 인터럽트 처리를 이용하여 메시지를 수신하는 처리의 흐름에 대해 설명한다. 즉, INTMASK 레지스터(88)에 "1"이 저장되어 있을 때에, 메시지 송신측의 노드와 메시지 수신측의 노드가 실행하는 처리의 흐름에 대해 설명한다. 도 25는 인터럽트 명령을 이용하여 사용자 프로세스에 도착 통지를 발행하는 처리의 흐름을 설명하기 위한 시퀀스도이다.

여기서, 사용자 프로세스 #1은, 발행 요구 플래그 레지스터(63)에 플래그 "1"을 저장함으로써 CPU(12)에 메시지의 송신을 지시한다(단계 S201). 그러면, CPU(12)는 메시지를 포함하는 패킷을 수신측 노드에 송신한다(단계 S202). 또한, 수신측 노드가 갖는 CPU는, 수신한 메시지를 메시지 기억 영역에 저장한다(단계 S203). 이 때, 수신측 노드가 갖는 CPU는, 라이트 포인터의 값을 갱신한다. 또한, 수신측 노드가 갖는 CPU는 완료 응답을 CPU(12)에 송신한다(단계 S204).

그러면, CPU(12)는, 응답 수신 플래그 레지스터(68)에 플래그 "1"을 저장함으로써 사용자 프로세스 #1에 메시지의 송신이 완료되었다는 취지를 통지한다. 그리고, 사용자 프로세스 #1은 응답 스테이터스 레지스터(66)의 값의 판독을 수행한다(단계 S205).

여기서, 수신측 노드가 실행하는 사용자 프로세스 #2는, 슬립 상태로 되어 있다(단계 S206). 따라서, 수신측 노드의 CPU는 응답을 CPU(12)에 송신하면, 도착 통지로서 인터럽트 요구 신호를 발행한다(단계 S207). 그러면, 노드 수신측의 드라이버는 컨텍스트 스위치를 실행하고(단계 S208), 슬립 상태이던 사용자 프로세스 #2를 실행한다. 그 후, 사용자 프로세스 #2는 메시지의 판독을 수행하고(단계 S209), 처리를 종료한다.

다음, 도 26을 이용하여, 송신측 노드에서 사용자 프로세스 #1이 메시지 #1을 송신할 때에 컨텍스트 스위치가 발생한 경우의 처리의 흐름에 대해 설명한다. 도 26은 송신측 노드에서 컨텍스트 스위치가 발생한 경우의 처리의 흐름을 설명하기 위한 시퀀스도이다.

예컨대, 송신측 노드의 사용자 프로세스 #1은, 메시지 #1을 메시지 데이터 레지스터(61)에 저장한다(단계 S301). 여기서, 컨텍스트 스위치가 발생하고, 드라이버(33)는 사용자 프로그램 #1의 세이브 및 리스토어 처리를 수행한다(단계 S302). 이 때, 메시지 데이터 레지스터(61)에 저장된 메시지 #1도 세이브 및 리스토어 처리의 대상이 된다.

다음, 컨텍스트 스위치에 의해 실행된 사용자 프로세스 #2가 메시지 #2를 메시지 데이터 레지스터(61)에 저장한다(단계 S303). 그리고, 사용자 프로세스 #2는 발행 요구 플래그 레지스터(63)에 "1"을 저장함으로써(단계 S304), CPU(12)에 메시지 #2를 포함하는 패킷을 송신시킨다(단계 S305).

그러면, 수신측 노드의 CPU는 메시지 #2를 메시지 기억 영역에 저장한다(단계 S306). 그리고, 수신측 노드의 CPU는, 인터럽트 요구 신호를 발행하고(단계 S307), 응답을 CPU(12)에 송신한다(단계 S308). 여기서, CPU(12)가 응답을 수신하면, 응답 수신 플래그 레지스터(68)에 "1"이 저장되므로, 사용자 프로세스 #2는 응답 스테이터스 레지스터(66)에 저장된 스테이터스의 판독을 수행한다(단계 S309). 그 후, 컨텍스트 스위치가 발생하고, 드라이버(32)는, 사용자 프로그램 #2의 세이브 및 리스토어 처리를 수행한다(단계 S310).

한편, 수신측 노드의 드라이버는 메시지 #2를 수신했을 때에 인터럽트 요구 신호가 발행되므로(단계 S307), 인터럽트 통지를 사용자 프로세스 #3에 발행한다(단계 S311). 그러면, 사용자 프로세스 #3은 메시지 #2의 판독을 수행한다(단계 S312).

여기서, 컨텍스트 스위치에 의해 실행된 사용자 프로세스 #1은 단계 S301에서 송신하는 메시지 #1을 메시지 데이터 레지스터(61)에 저장하고 있다. 따라서, 사용자 프로세스 #1은 발행 요구 플래그 레지스터(63)에 "1"을 저장함으로써(단계 S313), CPU(12)에 메시지 #1을 포함하는 패킷을 송신시킨다(단계 S314).

그러면, 수신측 노드의 CPU는 메시지 #1을 메시지 기억 영역에 저장한다(단계 S315). 그리고, 수신측 노드의 CPU는, 인터럽트 요구 신호를 발행하고(단계 S316), 응답을 CPU(12)에 송신한다(단계 S317). 여기서, CPU(12)가 응답을 수신하면, 응답 수신 플래그 레지스터(68)에 "1"이 저장되므로, 사용자 프로세스 #1은 응답 스테이터스 레지스터(66)에 저장된 스테이터스의 판독을 수행한다(단계 S318).

한편, 수신측 노드의 드라이버는, 메시지 #1을 수신했을 때에 인터럽트 요구 신호가 발행되므로(단계 S316), 인터럽트 통지를 사용자 프로세스 #3에 발행한다(단계 S319). 그러면, 사용자 프로세스 #3은 메시지 #1의 판독을 수행한다(단계 S320).

여기서, CPU(12)는 도 26 중 (a)에서 도시되는 기간 동안에는 사용자 프로세스 #1의 실행을 대기한다. 즉, CPU(12)는 메시지 송신 커맨드를 프로세스가 발행하고 나서, 응답 스테이터스 레지스터(66)에 스테이터스가 저장되고, 응답 수신 플래그 레지스터(68)에 플래그 "1"이 저장될 때까지, 메시지 송신 커맨드의 실행 완료를 대기한다. 따라서, 메시지 송신 커맨드를 프로세스가 발행한 직후에 컨텍스트 스위치가 발생했을 때에도, 프로세스측에서는 메시지 송신 커맨드를 발행한 직후에 응답을 수신한 것처럼 보인다. 따라서, CPU(12)는 컨텍스트 스위치가 발생해도, 프로세스의 실행을 정상적으로 정지 및 재개할 수 있다.

이와 같이, CPU(12)는, 라이트 포인터와 리드 포인터를 대응시킨 복수 개의 레지스터 세트를 기억하는 RAM(81)을 가지며, 메시지 송신원의 CPU에 레지스터 세트를 나타내는 레지스터 ID를 통지한다. 그리고, CPU(12)는 메시지와 함께, 레지스터 ID를 취득한 경우에는, 취득한 레지스터 ID가 나타내는 레지스터 세트의 라이트 포인터가 나타내는 메시지 기억 영역에 수신한 메시지를 저장한다. 또한, 다른 CPU(13 내지 15)도 동일한 처리를 실행한다. 따라서, CPU(12 내지 15)는, 송신측의 CPU가 라이트 포인터를 캐시하지 않고도, 프로세스간 통신을 수행할 수 있으므로, 어느 하나의 CPU가 고장났을 때에 다른 CPU로 고장이 파급되는 것을 방지할 수 있다.

또한, CPU(12)는, 동시에 실행 가능한 프로세스와 동일한 수의 제어 자원(60 내지 60c)을 갖는다. 즉, CPU(12)는 동시에 실행 가능한 프로세스와 동일한 수의 송신 큐를 갖는다. 또한, CPU(12)는 어느 한 프로세스에 대해 동시에 메시지를 송신하는 프로세스와 동일한 수의 레지스터 세트를 기억한다. 즉, CPU(12)는 실행중인 프로세스에 대해 동시에 메시지를 송신하는 프로세스와 동일한 수의 수신 큐를 갖는다. 따라서, CPU(12)는 프로세스간 통신에 수반되는 회로 규모의 증가를 방지하면서, 프로세스간 통신에서의 레이턴시를 경감할 수 있다.

한편, 종래 인피니밴드의 기술에서는, 송신측의 하드웨어에 준비된 송신 큐와, 수신측의 하드웨어에 준비된 수신 큐를 조합한 큐 페어를 이용하여, 프로세스간 통신을 수행한다. 구체적으로는, 송신 프로세스가 수신 프로세스와 통신을 수행하는 경우, 사전에 프로세스 사이에서 합의한 큐 페어를 확보하고, 송신측 프로세스 #1 내지 #3은 확보한 큐 페어에 메시지를 기입한다. 그리고, 수신측 프로세스 #1 내지 #3은 확보한 큐 페어로부터 메시지를 취득한다.

그러나, 종래의 인피니밴드의 기술에서는, 송신 프로세스와 수신 프로세스와의 세트마다 큐 페어를 준비할 필요가 있다. 예컨대, 도 27은 종래의 인피니밴드에서의 큐 페어의 기능을 설명하기 위한 도면이다. 도 27에 도시한 예에서는, 복수 개의 송신 프로세스 #1 내지 #3이 복수 개의 수신 프로세스 #1 내지 #3에 대해 메시지를 송신하는 예에 대해 기재했다.

여기서, 도 27에 도시한 예에서는, 송신 프로세스 #1 내지 #3과 수신 프로세스 #1 내지 #3이 프로세스간 통신을 실행하기 때문에, 송신측의 HCA(Host Channel Adapter) 하드웨어와 수신측의 HCA 하드웨어는, 각각 9개의 큐 페어를 준비할 필요가 있다. 이 결과, 종래의 인피니밴드의 기술에서는, 프로세스간 통신의 실현에 필요한 자원 수를 증가시키게 된다.

또한, 하나의 큐 페어를 복수 개의 프로세스가 공유함으로써, 자원 수를 증가시키지 않고 프로세스간 통신을 수행하는 방법도 생각할 수 있다. 도 28은 프로세스 사이에서 큐 페어를 공유화했을 때의 처리를 설명하기 위한 도면이다. 도 28에 도시한 바와 같이, 송신 프로세스 #1 내지 #3은 디바이스 드라이버 소프트웨어를 통해 큐 페어의 송신 큐를 공유한다. 또한, 수신 프로세스 #1 내지 #3은 디바이스 드라이버 소프트웨어를 통해 큐 페어의 수신 큐를 공유한다.

예컨대, 송신 프로세스 #1은, 송신측의 디바이스 드라이버 소프트웨어를 호출하고, 수신 프로세스 #2에 송신하는 메시지를 송신 큐에 기입하도록 의뢰한다. 이러한 경우에는, 송신측의 디바이스 드라이버 소프트웨어는 메시지를 송신 큐에 기입한다. 그러면, 수신측의 디바이스 드라이버 소프트웨어는, 수신 큐에 도착한 메시지를 판독하고, 읽어낸 메시지를 송신처의 수신 프로세스 #2에 통지한다.

그러나, 하나의 큐 페어를 공유하는 기술에서는, 송신측 프로세스 #1 내지 #3이 디바이스 드라이버 소프트웨어를 판독하고, 메시지의 송신을 의뢰하고, 수신측 프로세스 #1 내지 #3은 디바이스 드라이버 소프트웨어를 통해 메시지를 취득한다. 따라서, 메시지의 송수신이 수행될 때마다 컨텍스트 스위치가 발생하여, 프로세스간 통신을 수행할 때의 지연 시간이 악화되어 버린다.

한편, CPU(12)는 동시에 실행 가능한 프로세스와 동일한 수의 송신 큐를 가지므로, 각 프로세스가 메시지를 송신할 때에 큐의 부족이 발생하지 않는다. 또한, CPU(12)는 실행중인 프로세스에 대해 동시에 메시지를 송신하는 프로세스와 동일한 수의 수신 큐를 가지므로, 메시지를 수신할 때에 큐의 부족이 발생하지 않는다. 따라서, CPU(12)는 모든 프로세스간의 큐 페어를 준비하지 않고도, 프로세스간 통신을 수행할 때의 지연 시간을 악화시키지 않고, 프로세스간 통신을 수행할 수 있다.

다음, 도 29 내지 도 32를 이용하여 CPU(12)가 실행하는 프로세스가 실행하는 처리의 흐름에 대해 설명한다. 먼저, 도 29를 이용하여, 새로운 메시지 큐를 획득한 프로세스가 실행하는 처리의 흐름에 대해 설명한다. 도 29는 새로운 메시지 큐를 획득한 프로세스가 실행하는 처리의 흐름을 설명하기 위한 플로 차트이다.

먼저, 프로세스는, M 사이즈 및 Q 사이즈를 지정하여 메시지 큐를 획득하기 위한 드라이버(33)를 호출한다(단계 S401). 다음, 프로세스는 메시지 큐를 획득할 수 있었는지 여부를 판별하고(단계 S402), 메시지 큐를 획득할 수 없었던 경우에는(단계 S402 부정), 이상 종료 통지를 발행한다.

한편, 프로세스는, 메시지 큐를 취득할 수 있었던 경우에는(단계 S402 긍정), MSGQ-ID를 송신측 노드가 실행하는 프로세스에 통지한다(단계 S403). 계속해서, 프로세스는 인터럽트에 의한 수신 대기를 수행할 것인지 여부를 판별하고(단계 S404), 인터럽트에 의한 수신 대기를 수행하는 경우에는(단계 S404 긍정), INTMASK를 "1"로 세팅하여(단계 S405), 처리를 종료한다. 한편, 프로세스는 인터럽트에 의한 수신 대기를 수행하지 않는 경우에는(단계 S404 부정), 폴링에 의한 수신 메시지 감시를 수행하고(단계 S406), 처리를 종료한다.

다음, 도 30을 이용하여 드라이버(33)가 메시지 큐를 획득하는 처리에 대해 설명한다. 도 30은 드라이버가 새로운 메시지 큐를 획득하는 처리의 흐름을 설명하기 위한 플로 차트이다. 또한, 도 30에 도시한 처리는, 도 29 중의 단계 S401에서 호출된 드라이버가 실행하는 처리이다.

예컨대, 드라이버(33)는 RAM(81)이 기억하는 레지스터 세트를 어느 하나의 프로세스에 할당했는지 여부를 나타내는 레지스터 세트 관리 테이블을 체크한다(단계 S501). 또한, 레지스터 세트 관리 테이블은, 예컨대, 메모리(18, 19)에 저장된다. 그리고, 드라이버(33)는 어느 하나의 프로세스에 할당되지 않은 빈 레지스터 세트가 존재하는지 여부를 판별한다(단계 S502).

그리고, 드라이버(33)는 빈 레지스터 세트가 존재하는 경우에는(단계 S502 긍정), 빈 레지스터 세트를 획득하고, 지정된 M 사이즈, Q 사이즈로부터 메시지 기억 영역에 필요한 용량을 계산한다(단계 S503). 다음, 드라이버(33)는 계산한 용량의 메모리를 획득할 수 있는지 여부를 판별하고(단계 S504), 획득할 수 있는 경우에는(단계 S504 긍정), 메모리 키의 값을 결정한다(단계 S505).

계속해서, 드라이버(33)는 획득한 빈 레지스터 세트를 초기화하고(단계 S506), 획득한 레지스터 세트를 나타내는 레지스터 ID와 메모리 키의 값으로부터 MSGQ-ID를 생성하고, 호출원의 프로세스에 통지하고(단계 S507), 처리를 종료한다. 한편, 드라이버(33)는, 빈 레지스터 세트가 존재하지 않는 경우나(단계 S502 부정), 메모리를 획득할 수 없었던 경우에는(단계 S504 부정), 호출원의 프로세스에 메시지 큐를 취득할 수 없었다는 취지를 통지하고, 이상 종료한다.

다음, 도 31을 이용하여 CPU(12)가 메시지를 송신하는 처리의 흐름에 대해 설명한다. 도 31은 송신측의 CPU에서의 메시지 송신 처리의 흐름을 설명하기 위한 플로 차트이다. 먼저, CPU(12)는, 송신할 메시지의 사이즈가 소정의 비트 길이보다 긴 롱 사이즈인지 여부를 판별한다(단계 S601).

그리고, CPU(12)는 메시지의 사이즈가 롱 사이즈인 경우에는(단계 S601 긍정), 공유 메모리 상에 송신 메시지를 저장한다(단계 S602). 다음, CPU(12)는 메시지를 저장한 메모리 어드레스와 메시지 길이를 메시지 데이터 레지스터(61)에 저장한다(단계 S603). 한편, CPU(12)는, 메시지의 사이즈가 롱 사이즈가 아니라고 판별한 경우에는(단계 S601 부정), 메시지를 메시지 데이터 레지스터(61)에 저장한다(단계 S604).

다음, CPU(12)는 MSGQ-ID를 세팅하고, 메시지를 송신한다(단계 S605). 다음, CPU(12)는, 응답 스테이터스 레지스터(66)의 판독을 수행하고(단계 S606), OVFL이 "1"인지 여부를 판별한다(단계 S607). 즉, CPU(12)는 오버플로우가 발생했는지 여부를 판별한다. 그리고, CPU(12)는 OVFL이 "1"이라고 판별한 경우에는(단계 S607 긍정), 다시 단계 S605를 실행한다. 한편, CPU(12)는 OVFL이 "1"이 아니라고 판별한 경우에는(단계 S607 부정), PROT가 "1"인지 여부를 판별한다(단계 S608).

즉, CPU(12)는, 메모리 키의 값과 액세스 키의 값이 일치했는지 여부를 판별한다. 그리고, CPU(12)는, PROT가 "0"이라고 판별한 경우에는(단계 S608 부정), 정상 종료하고, PROT가 "1"이라고 판별한 경우에는(단계 S608 긍정), 실행중인 프로세스에 이상 종료 통지를 발행하고, 처리를 종료한다.

다음, 도 32를 이용하여, CPU(12)가 메시지를 수신했을 때의 처리의 흐름에 대해 설명한다. 도 32는 수신측의 CPU에서의 메시지 수신 처리의 흐름을 설명하기 위한 플로 차트이다. 또한, 도 32에 도시한 예에서는, 메시지의 수신을 폴링에 의해 기다리는 경우와, 인터럽트 요구에 의해 메시지의 수신을 식별하는 경우를 모두 기재했다.

예컨대, CPU(12)는, 폴링에 의해 메시지의 수신을 기다리는 경우에는, 리드 포인터와 라이트 포인터를 판독한다(단계 S701). 그리고, CPU(12)는 리드 포인터와 라이트 포인터가 일치하는지 여부를 판별하고(단계 S702), 일치한다고 판별한 경우에는(단계 S702 긍정), 다시 단계 S701의 처리를 실행한다. 한편, CPU(12)는 리드 포인터와 라이트 포인터가 일치하지 않는다고 판별한 경우에는(단계 S702 부정), 리드 포인터에 따라 메모리로부터 메시지의 판독을 수행한다(단계 S703).

다음, CPU(12)는 리드 포인터의 값을 갱신하고(단계 S704), 수신한 메시지를 해석한다(단계 S705). 그리고, CPU(12)는 수신한 메시지에 메모리 어드레스가 저장되어 있는지 여부에 따라, 수신한 메시지가 롱 사이즈인지 여부를 판별한다(단계 S706). 그 후, CPU(12)는 메시지가 롱 사이즈라고 판별한 경우에는(단계 S706 긍정), 메시지 중의 어드레스를 이용하여 공유 메모리로부터 롱 메시지를 판독하고(단계 S707), 처리를 종료한다. 한편, CPU(12)는 메시지가 롱 사이즈가 아니라고 판별한 경우에는(단계 S706 부정), 처리를 종료한다.

또한, CPU(12)는 인터럽트 통지에 의해 메시지의 수신을 식별하는 경우에는, 인터럽트 요구가 발행된 것을 트리거로 하여, 리드 포인터와 라이트 포인터의 판독을 수행한다(단계 S708). 그리고, CPU(12)는 리드 포인터와 라이트 포인터가 일치하는지 여부를 판별하고(단계 S709), 일치한다고 판별한 경우에는(단계 S709 긍정), 이상 종료 통지를 발행하고 처리를 종료한다. 한편, CPU(12)는, 리드 포인터와 라이트 포인터가 일치하지 않는다고 판별한 경우에는(단계 S709 부정), 단계 S703의 처리를 실행한다.

[실시예 1의 효과]

전술한 바와 같이, CPU(12)는 라이트 포인터와 리드 포인터를 대응시킨 복수 개의 레지스터 세트를 기억하고, 레지스터 세트를 식별하는 레지스터 ID를 메시지 송신측의 노드에 통지한다. 그리고, CPU(12)는 메시지와 레지스터 ID를 수신한 경우에는, 수신한 레지스터 ID가 나타내는 레지스터 세트의 라이트 포인터에 따라, 수신한 메시지를 메모리(18, 19)에 저장한다.

따라서, CPU(12)는 공유 메모리를 이용한 멀티노드 시스템의 기술이 적용된 프로세스간 통신에 있어서, 노드의 고장이 발생했을 때에 다른 노드로 고장이 전파하는 것을 방지할 수 있다. 즉, CPU(12)는 메시지를 송신할 때에, 라이트 포인터를 캐시하지 않고도 적절하게 메시지의 송신을 수행할 수 있다. 이 결과, CPU(12)는 고장났을 때에 다른 CPU(13 내지 15)로 고장이 전파되는 것을 방지할 수 있다.

또한, CPU(12)는 동시에 실행 가능한 프로세스의 수만큼, 제어 자원(60 내지 60c)을 갖는다. 따라서, CPU(12)는 프로세스가 큐를 확보할 때의 지연 시간을 증가시키지 않고 메시지의 전송을 수행할 수 있다.

나아가, CPU(12)는 실행중인 프로세스가 다른 노드에 대해 메시지를 송신한 경우에는, 메시지에 대한 응답을 수신할 때까지의 동안에, 실행중인 프로세스의 프로그램의 진행을 정지한다. 예컨대, CPU(12)는 메시지를 메모리(18, 19)에 저장한 경우에는, 메시지의 송신원에 응답을 송신하는 기능을 갖는다. 그리고, CPU(12)는 프로세스가 발행 요구 플래그 레지스터(63)에 "1"을 저장하고나서, 응답 수신 플래그 레지스터(68)에 "1"이 저장되어 코어에 대해 리퀘스트 완료 통지를 송신할 때까지의 동안에, 코어에서 실행되는 프로그램의 진행을 정지시킨다. 이 결과, 프로세스는 응답 스테이터스 레지스터(66)의 판독을 수행했을 때에, 자신이 송신한 메시지에 대한 응답의 스테이터스를 판독할 수 있다.

또한, CPU(12)는, 자신이 실행하는 프로세스에 대해 메시지를 송신하는 프로세스의 수 또는 자신이 실행하는 프로세스에 대해 메시지를 송신하는 프로세스의 수보다 많은 포인터 세트를 기억한다. 따라서, CPU(12)는 실행하는 프로세스의 모든 조합에 대해 큐를 준비하지 않고도 프로세스간 통신을 실현할 수 있다. 이 결과, CPU(12)는 회로 규모를 증가시키지 않고, 프로세스간 통신에서의 지연 시간의 악화를 방지할 수 있다.

또한, CPU(12)는 프로세스가 메시지를 직접 메시지 데이터 레지스터(61)에 기입한다. 또한, CPU(12)는, 메시지가 수신되었을 때에도 디바이스 드라이버를 호출하지 않고도 직접 메시지를 메시지 기억 영역에 기입한다. 이 결과, 디바이스 드라이버를 호출하기 위한 컨텍스트 스위치를 수행할 때의 오버헤드에 의한 지연이 발생하지 않으므로, CPU(12)는 프로세스간 통신의 레이턴시 성능을 양호하게 유지할 수 있다.

또한, CPU(12)는, 메시지가 롱 메시지인 경우에는 메시지를 공유 메모리(18)에 저장하고, 롱 메시지를 저장한 메모리 어드레스를 메시지 대신 송신한다. 그리고, CPU(12)는 메시지 대신 메모리 어드레스를 수신한 경우에는, 공유 메모리(18) 중 수신한 메모리 어드레스가 나타내는 기억 영역으로부터 롱 메시지를 취득한다. 따라서, CPU(12)는 메시지의 길이가 소정의 임계값보다 긴 롱 메시지인 경우에도, 레이턴시를 증가시키지 않고 프로세스간 통신을 수행할 수 있다.

또한, CPU(12)는 메시지 송신측의 노드에 액세스 키를 통지한다. 그리고, CPU(12)는, 메시지 송신측의 노드로부터 메시지와 함께 수신한 액세스 키가 자신이 기억하는 메모리 키와 일치하는지 여부를 판별하고, 일치한다고 판별한 경우에는 메시지를 메시지 기억 영역에 저장한다. 따라서, CPU(12), 프로그램 미스나 악의가 있는 프로그램에 의한 메시지의 파괴를 방지할 수 있다.

또한, CPU(12)는 복수 개의 레지스터 세트를 RAM(81)에 저장한다. 그리고, CPU(12)는 메시지와 함께 수신한 레지스터 ID가 나타내는 레지스터 세트를 일시 레지스터군(82)에 저장한다. 따라서, CPU(12)는 레지스터 세트를 기억하는 많은 레지스터를 실제로 갖지 않아도 되므로, 회로 규모를 증가시키지 않고 프로세스간 통신을 실현할 수 있다.

또한, CPU(12)는 메시지의 저장을 수행한 경우에는, 라이트 포인터의 값을 갱신한다. 또한, CPU(12)는 라이트 포인터와 리드 포인터의 값이 일치하는지 여부를 판별하고, 일치하지 않는다고 판별한 경우에는 리드 포인터에 따라 메모리(18, 19)로부터 메시지의 판독을 수행한다. 따라서, CPU(12)는 복잡한 처리를 수행하지 않고, 메시지의 수신을 기다릴 수 있다.

<실시예 2>

전술한 실시예 1에서는, CPU(12)가 실행하는 프로세스는 응답 스테이터스 레지스터에 저장된 OVFL이 "1"인 경우에는, 오버플로우가 발생했다고 판별하고, 메시지의 송신을 재실행했다. 그러나, 실시예는 이에 한정되지 않는다.

즉, 실시예 1에 따른 CPU(12)는, 프로세스가 연속적으로 메시지의 송신을 실행한 경우에는 처리 시간을 낭비해 버리는 경우가 있다. 예컨대, CPU(12)는 수신측의 노드가 장시간 동안 어떠한 처리를 실행하고 있는 경우에는, 수신측의 메시지 큐가 언제 해방되는지 알 수 없다. 이 결과, CPU(12)는 수신측의 메시지 큐가 해방될 때까지 메시지의 송신을 계속 실행하게 된다.

따라서, 실시예 2에 따른 CPU(12a)는, 메시지를 송신할 때에 오버플로우 상태라는 취지의 응답을 수신한 경우에는, 메시지를 송신하는 프로세스를 정지하고, 다른 프로세스를 실행함으로써 처리 시간의 낭비를 해소한다.

이하, 도면을 이용하여 실시예 2에 따른 CPU(12a)에 대해 설명한다. 도 33은 실시예 2에 따른 수신 제어부의 기능 구성을 설명하기 위한 도면이다. 또한, 도 33에 도시한 것 중 실시예 1과 동일한 처리를 수행하는 것에 대해서는, 도 15에서 도시한 부호와 동일한 부호를 붙이고 이하의 설명을 생략한다. CPU(12a)는 실시예 1에 따른 CPU(12)와 동일한 구성을 가지고, 도 33에 도시한 예에서는 CPU(12a)는 수신 제어부(58a)를 갖는다.

수신 제어부(58a)는 실시예 1에 따른 수신 제어부(58)와 동일한 기능을 가지고, RAM(81)과 마찬가지로 복수 개의 레지스터 세트를 기억하는 RAM(81a)을 갖는다. 또한, 수신 제어부(58a)는 수신 제어부(58)가 갖는 일시 레지스터군(82) 중 INTMASK 레지스터(88)를 INTMASK/오버플로우 레지스터(88a)로 한 것이다.

먼저, 도 34, 도 35를 이용하여 RAM(81a)이 기억하는 레지스터 세트에 대해 설명한다. 도 34는 실시예 2에 따른 RAM의 필드의 정의를 설명하기 위한 도면이다. 도 34에 도시한 바와 같이, RAM(81a)은 실시예 1에 따른 RAM(81)이 기억하는 레지스터 세트 이외에, OVFL 비트(오버플로우 비트)를 기억한다. 상세하게는, RAM(81a)은 83비트의 엔트리 중 77번째 비트를 OVFL 비트로 하고, 다른 82비트에 실시예 1에 따른 레지스터 세트와 동일한 정보를 저장한다.

도 35는 실시예 2에 따른 RAM의 필드에 저장되는 데이터의 내용을 설명하기 위한 도면이다. 도 35에 도시한 바와 같이, RAM(81a)은 메시지 착신시에 큐의 오버플로우가 발생했는지 여부를 나타내는 1비트의 OVFL 비트를 기억한다. 또한, 도 35에 도시한 바와 같이, RAM(81a)이 기억하는 다른 정보에 대해서는, RAM(81)이 기억하는 정보와 동일한 정보이기 때문에 설명을 생략한다.

다음, 도 36을 이용하여 INTMASK/오버플로우 레지스터(88a)에 대해 설명한다. 도 36은 실시예 2에 따른 소프트웨어에서 본 수신 제어부의 어드레스의 일례를 설명하기 위한 도면이다. 예컨대, INTMASK/오버플로우 레지스터(88a)는 INTMASK 이외에 메시지를 수신했을 때에 큐의 오버플로우가 발생했는지 여부를 나타내는 OVFL 비트를 기억하는 레지스터이다.

여기서, INTMASK/오버플로우 레지스터(88a)는, 도 36에 도시한 바와 같이, 다른 레지스터(83 내지 87)와 마찬가지로 소프트웨어에서 보았을 때에 어드레스가 부여되어 있다. 예컨대, 도 36에 도시한 예에서는, INTMASK/오버플로우 레지스터(88a)가 INTMASK를 기억하는 범위에 대해서는 실시예 1과 마찬가지로 "0x10" 내지 "0x17"의 어드레스가 부여되어 있다. 또한, INTMASK/오버플로우 레지스터(88a)가 OVFL 비트를 기억하는 범위에 대해서는 "0x40" 내지 "0x47"이 부여되어 있다.

이하, 도 33으로 돌아가, 수신 제어부(58a)가 실행하는 처리에 대해 설명한다. 예컨대, 수신 제어부(58a)는 로컬 XB(16)로부터 메시지를 수신하면, 일치 검사부(91)를 이용하여 수신한 메시지를 저장하는 메시지 기억 영역에 새로운 메시지를 저장할 수 있는지 여부를 판별한다. 즉, 수신 제어부(58a)는 메시지를 수신하면, 오버플로우가 발생했는지 여부를 판별한다.

그리고, 수신 제어부(58a)는 오버플로우가 발생한 경우, 응답의 OVFL 비트를 "1"로 함으로써 메시지 송신측의 노드에 오버플로우가 발생했다는 취지를 통지한다. 또한, 수신 제어부(58a)는 RAM(81a)이 기억하는 각 정보 중 메시지와 함께 수신한 레지스터 ID가 나타내는 엔트리의 OVFL 비트를 "1"로 한다.

또한, 수신 제어부(58a)는 업데이트 레지스터에 대한 라이트 요구에 의해 리드 포인터가 갱신될 때에, OVFL 비트가 "1"인 경우에는 인터럽트 생성 회로(96)를 이용하여 인터럽트 요구 신호를 출력한다. 이러한 경우에는, 드라이버(33)는 오버플로우가 발생했기 때문에 메시지 기억 영역에 메시지를 저장할 수 없던 메시지 송신원의 노드에 비었다는 통지를 송신한다.

여기서, 도 37은 실시예 2에 따른 RAM의 필드를 갱신하는 처리를 설명하기 위한 도면이다. 도 37에 도시한 바와 같이, RAM 주변부(78)는 엔트리의 초기화를 수행하는 경우에는 OVFL 비트를 "0"으로 갱신하고, 메시지를 기입하는 경우에는, OVFL 비트의 값을 갱신치로 갱신한다. 즉, RAM 주변부(78)는 메시지를 기입할 때에 오버플로우가 발생한 경우에는 "1"을, 오버플로우가 발생하지 않은 경우에는 "0"을 저장한다. 또한, RAM 주변부(78)는 인터럽트 마스크의 변경이나 메시지의 판독을 수행하는 경우에는 OVFL 비트의 값을 불변으로 한다. 또한, 도 37에 도시한 각 정보 중 OVFL 비트 이외의 필드에 대해서는, 도 20에 도시한 처리와 동일한 처리를 수행하는 것으로 하고 설명을 생략한다.

다음, 도 38을 이용하여 오버플로우가 발생했을 때에 CPU(12a)가 실행하는 프로세스의 동작에 대해 설명한다. 도 38은 실시예 2에 있어서 오버플로우가 발생했을 때에 실행하는 처리의 흐름을 설명하기 위한 시퀀스도이다.

예컨대, 사용자 프로세스 #1은, 발행 요구 플래그 레지스터(63)에 플래그 "1"을 저장함으로써, CPU(12a)에 메시지의 송신을 지시한다(단계 S801). 그러면, CPU(12a)는 메시지를 포함하는 패킷을 수신측 노드에 송신한다(단계 S802). 또한, 수신측 노드가 갖는 CPU는, 메시지 기억 영역이 FULL 상태(가득찬)이기 때문에(단계 S803), 오버플로우를 검출한다(단계 S804).

그리고, 수신측 노드가 갖는 CPU는, OVFL 비트를 "1"로 한 응답을 CPU(12a)에 송신한다(단계 S805). 또한 수신측 노드가 갖는 CPU는 송신한 메시지에 관한 RAM(81a)의 오버플로우 비트를 "1"로 세팅한다(단계 S806). 다음 사용자 프로세스 #1은 응답 스테이터스 레지스터(66)의 값의 판독을 수행하고, OVFL 비트를 검출한다(단계 S807). 다음, 사용자 프로세스 #1은 대기 리스트에의 추가 의뢰를 수신측 노드가 실행하는 드라이버에 송신한다(단계 S808).

그러면, 수신측의 노드가 실행하는 드라이버는 대기 리스트에 사용자 프로세스 #1을 추가한다(단계 S809). 그리고, 수신측의 노드가 실행하는 드라이버는 대기 리스트에의 등록 완료 통지를 사용자 프로세스 #1에 송신한다(단계 S810). 그러면, 사용자 프로세스 #1은 빈 공간 대기 상태(슬립)로 이행한다(단계 S811). 이 동안 CPU(12a)는 사용자 프로세스 #1 이외의 프로세스를 실행하는 것으로 할 수도 있다.

다음, 수신측 노드가 실행하는 사용자 프로세스 #2는 메시지의 판독을 실행한다(단계 S812). 그러면, 수신측 노드의 CPU는, 메시지 기억 영역에 빈 공간이 발생했다고 판별하고(단계 S813), 나아가서는 RAM(81a)의 오버플로우 비트가 "1"이므로 오버플로우를 검출하여 슬립 상태로 되어 있는 송신측 프로세스가 존재하는 것을 검지하여, 인터럽트 처리를 드라이버에 통지한다(단계 S814). 그러면, 수신측 노드의 드라이버는 대기 리스트를 확인하고(단계 S815), 사용자 프로세스 #1이 대기 리스트에 등록되어 있다고 판별한다.

이 결과, 수신측 노드의 드라이버는 비었다는 통지를 드라이버(32)에 통지한다(단계 S816). 그러면, 드라이버(32)는 컨텍스트 스위치를 실행하고(단계 S817), 사용자 프로세스 #1을 동작시킨다. 이 결과, 사용자 프로세스 #1은 메시지 #1을 메시지 데이터 레지스터(61)에 저장하고, CPU(12a)가 메시지 #1의 재송신을 수행한다.

다음, 도 39를 이용하여, CPU(12a)가 오버플로우 발생시에 실행하는 처리의 흐름에 대해 설명한다. 도 39는 실시예 2에 따른 CPU가 오버플로우의 발생시에 실행하는 처리의 흐름을 설명하기 위한 플로 차트이다. 또한, 도 39에 도시한는 단계 S901 내지 S908에 대해서는, 도 31에 도시한 단계 S601 내지 S608과 동일한 처리를 실행하는 것으로 하고 설명을 생략한다.

예컨대, CPU(12a)는 OVFL 비트가 "1"인 경우에는, 드라이버(32)에 빈 공간 대기 인터럽트를 의뢰한다(단계 S909). 그러면, 드라이버(32)는 대기 리스트에의 추가 의뢰를 메시지 송신처의 노드에 송신하고, 등록 완료 통지를 수신한다. 그 후, CPU(12a)는 실행하는 프로세스를 슬립시켜, 처리를 종료한다. 한편, CPU(12a)는 메시지 송신처의 노드로부터 비었다는 통지를 수신하면, 프로세스를 슬립으로부터 재개시키고, 단계 S905의 처리를 실행한다. 또한, 다른 처리의 흐름에 대해서는 도 31에 도시한 처리와 동일하기 때문에, 설명을 생략한다.

[실시예 2의 효과]

전술한 바와 같이, 수신측 노드의 CPU는, 응답에 OVFL 비트를 포함시켜 송신하고, RAM(81a) 내의 오버플로우 비트를 세팅한다. 그리고, CPU(12a)는 메시지 송신처의 노드로부터 통지된 응답에 포함되는 OVFL 비트가, 새로운 메시지를 수신할 수 없다는 취지를 나타내는 경우에는, 이하의 처리를 실행한다. 즉, CPU(12a)는 메시지 송신처의 노드에 대해 대기 리스트에의 추가 의뢰를 송신하고, 메시지를 송신하는 프로세스를 정지시키고 다른 프로세스를 실행한다.

그리고, CPU(12a)는 메시지 송신처의 노드로부터 비었다는 통지를 수신하면, 정지시킨 프로세스를 실행하고 다시 메시지를 송신한다. 따라서, CPU(12a)는 처리 시간의 낭비를 해소할 수 있다.

<실시예 3>

지금까지 본 발명의 실시예에 대해 설명했으나, 실시예는 전술한 실시예 이외에도 다양한 상이한 형태로 실시되어도 좋은 것이다. 따라서, 이하에서는 실시예 3으로서 본 발명에 포함되는 다른 실시예를 설명한다.

(1) RAM이 기억하는 정보에 대해

전술한 CPU(12, 12a)는 레지스터 세트를 기억하는 RAM(81, 81a)을 가지고 있었다. 그러나, 실시예는 이에 한정되지 않으며, 예컨대, CPU(12, 12a)는 각 레지스터 세트를 기억하는 레지스터를 실제로 구비하는 것으로 해도 된다. 또한, CPU(12, 12a)는 RAM(81, 81a)으로부터 판독된 레지스터 세트를 일시 레지스터군(82)이 아니라, FF 등의 버퍼에 저장하는 것으로 해도 된다.

(2) 메시지 저장 영역에 대해

전술한 CPU(12, 12a)는, 메모리(17, 18)에 메시지 기억 영역을 설정했다. 그러나, 실시예는 이에 한정되지 않으며, 예컨대, CPU(12, 12a)는 다른 CPU(13 내지 15)와 공유하는 공유 메모리 영역에 대해 메시지 기억 영역을 설정하는 것으로 해도 된다.

(3) 제어 자원에 대해

전술한 CPU(12)는 각 코어(40 내지 40b)마다 제어 자원(60 내지 60c)을 가지고 있었다. 그러나, 실시예는 이에 한정되지 않는다. 예컨대, 각 코어(40 내지 40b)가 스레딩(threading)의 기술을 이용하여 2개의 프로세스를 실행할 수 있는 경우에는, 각 코어(40 내지 40b)마다 2개의 제어 자원을 가져도 된다. 또한, 예컨대, 코어(40b)가 실행하는 프로세스를 한정하고, 다른 프로세스와 프로세스간 통신을 수행하지 않는 프로세스만을 코어(40b)에 실행시키는 경우에는, 코어(40b)의 제어 자원을 갖지 않는 것으로 해도 된다.

1 내지 1d…정보 처리 시스템 2, 2a…클라이언트 단말
3, 5…LAN 스위치 4…관리 단말
6…글로벌 크로스바 7…서비스 프로세서
10 내지 10m…노드 11…서비스 프로세서
12 내지 15, 12a…CPU 16…로컬 XB
17 내지 24…메모리 25…PCIe 스위치
26, 27…LAN 어댑터 28…SAS
29…HDD 30 내지 30c…하드웨어
31 내지 31c…하이퍼바이저 32 내지 32c…오퍼레이팅 시스템
33 내지 33c…드라이버 34 내지 34c…미들웨어
35, 35a…애플리케이션 40 내지 40b…코어
41 내지 41b…L1 캐시 태그 42 내지 42b…L1 캐시
43 내지 43b…TLB 44…L2 캐시 액세스 컨트롤러
45…L2 캐시 태그 46…L2 캐시
47…어드레스 맵 48…설정 레지스터군
49…PCI 제어부 50…디렉토리 제어부
51…캐시 코히런시 트랜잭션 제어부 53…메모리 R/W 버스
54…레지스터 R/W 버스 56…MSGQ 제어부
57…송신 제어부 58…수신 제어부
59…어드레스 디코더 60 내지 60c…제어 자원
61…메시지 데이터 레지스터 62…MSGQ-ID 레지스터
63…발행 요구 플래그 레지스터 64…송신 패킷 생성부
65, 69…셀렉터 66…응답 스테이터스 레지스터
67, 70…리드 데이터 셀렉터 68…응답 수신 플래그 레지스터
71…패킷 수신부 72…리퀘스트 큐
73…실행 레지스터 74…메모리 리퀘스트 제어부
75…메모리 리퀘스트 생성부 76…메모리 리퀘스트 레지스터
77…라이트 데이터 레지스터 78…RAM 주변부
79…RAM 어드레스 선택 회로 80…라이트 데이터 생성부
81, 81a…RAM 82…일시 레지스터군
83…BADRS 레지스터 84…MKEY 레지스터
85…WDP 레지스터 86…RDP 레지스터
87…Q 사이즈/M 사이즈 레지스터 88…INTMASK 레지스터
88a…INTMASK/오버플로우 레지스터 89…커맨드 실행부
90…불일치 검사부 91…일치 검사부
92…가산치 생성부 93…가산기
94…응답 패킷 생성부 95…응답 커맨드 레지스터
96…인터럽트 생성 회로

Claims (10)

1. 각각이 프로세서 및 기억 장치를 구비하는 복수 개의 노드를 갖는 정보 처리 장치에 있어서,
   상기 노드는,
   상기 노드 사이에서 송수신하는 데이터를 상기 기억 장치에 저장할 때의 어드레스를 나타내는 라이트 포인터와, 상기 데이터를 상기 기억 장치로부터 판독할 때의 어드레스를 나타내는 리드 포인터를 대응시킨 복수 개의 포인터 세트를 기억하는 기억부와,
   상기 포인터 세트를 나타내는 포인터 식별자를 상기 데이터의 송신원이 되는 노드에 통지하는 통지부와,
   상기 데이터의 송신원이 되는 노드가 송신한 상기 데이터와, 그 데이터의 송신원이 되는 노드에 상기 통지부가 통지한 포인터 식별자를 수신한 경우에는, 그 포인터 식별자가 나타내는 포인터 세트의 라이트 포인터가 나타내는 어드레스에 따라, 그 수신한 데이터를 상기 기억 장치에 저장하는 저장부
   를 포함하는 것을 특징으로 하는 정보 처리 장치.
2. 제1항에 있어서, 상기 노드는, 송신처가 되는 노드로부터 통지받은 포인터 식별자와 상기 데이터를 상기 송신처가 되는 노드에 송신하는 송신부를, 상기 프로세서가 동시에 실행할 수 있는 프로세스의 수만큼 가지며,
   상기 노드는, 실행중인 프로세스가 다른 노드에 대해 상기 데이터를 송신한 경우에는, 그 데이터에 대한 응답을 수신할 때까지의 동안에, 그 프로세스의 프로그램의 진행을 정지하는 것을 특징으로 하는 정보 처리 장치.
3. 제2항에 있어서, 상기 노드는, 상기 저장부가 상기 데이터를 상기 기억 장치에 저장한 경우에는, 그 데이터의 송신원이 되는 노드에 대해 응답을 송신하는 응답부를 가지며,
   상기 기억부는, 자신의 노드가 실행하는 프로세스 중, 동시에 상기 데이터를 수신하는 프로세스의 수와 동일하거나, 또는 그 이상의 수만큼 상기 포인터 세트를 기억하는 것을 특징으로 하는 정보 처리 장치.
4. 제2항에 있어서, 상기 정보 처리 장치는, 각 노드가 공유하는 공유 메모리를 가지며,
   상기 송신부는, 상기 데이터를 상기 공유 메모리에 저장하고, 그 데이터를 저장한 공유 메모리의 메모리 어드레스를 상기 포인터 식별자와 함께 상기 데이터의 송신처가 되는 노드에 송신하고,
   상기 저장부는, 상기 포인터 식별자와 상기 메모리 어드레스를 수신한 경우에는, 그 포인터 식별자가 나타내는 포인터 세트의 라이트 포인터가 나타내는 어드레스에 따라, 그 수신한 메모리 어드레스를 저장하고,
   상기 데이터의 송신처가 되는 노드가 실행하는 프로세스는, 상기 저장부가 상기 기억 장치에 저장한 메모리 어드레스에 따라, 상기 공유 메모리로부터 상기 데이터를 취득하는 것을 특징으로 하는 정보 처리 장치.
5. 제2항 내지 제4항 중 어느 한 항에 있어서, 상기 기억부는 상기 포인터 세트마다 키 정보를 기억하고,
   상기 통지부는, 상기 포인터 식별자와 그 포인터 식별자가 나타내는 포인터 세트의 키 정보를 상기 데이터의 송신원이 되는 노드에 통지하고,
   상기 송신부는, 상기 포인터 식별자와 상기 데이터와 상기 키 정보를 송신하고,
   상기 저장부는, 상기 데이터의 송신원이 되는 노드로부터 수신한 포인터 식별자가 나타내는 포인터 세트에 대해 상기 기억부가 기억하는 키 정보와 그 포인터 식별자와 함께 수신한 키 정보가 일치하는 경우에는, 그 포인터 세트의 라이트 포인터가 나타내는 어드레스에 따라 그 수신한 데이터를 저장하는 것을 특징으로 하는 정보 처리 장치.
6. 제3항에 있어서, 상기 응답부는 자신의 노드가 새로운 데이터를 수신할 수 있는지 여부를 나타내는 오버플로우 비트를 상기 응답과 함께 송신하고,
   상기 송신부는, 상기 송신처의 노드로부터 통지받은 오버플로우 비트가 새로운 데이터를 수신할 수 없다는 취지를 나타내는 경우에는, 상기 데이터의 송신처가 되는 노드에 대해, 새로운 데이터를 기억할 여유가 생겼을 때에 통지를 수행하도록 요청하고, 그 통지를 수신할 때까지의 동안에, 그 메시지를 송신하는 프로세스를 정지시키는 것을 특징으로 하는 정보 처리 장치.
7. 제1항 내지 제4항, 또는 제6항 중 어느 한 항에 있어서, 상기 기억부는, 복수 개의 상기 포인터 세트를 기억하는 메모리와,
   상기 데이터의 송신원이 되는 노드로부터 수신한 포인터 식별자가 나타내는 포인터 세트를 상기 메모리로부터 취득하는 취득부와,
   상기 취득부가 취득한 포인터 세트를 일시적으로 유지하는 레지스터
   를 포함하는 것을 특징으로 하는 정보 처리 장치.
8. 제1항 내지 제4항, 또는 제6항 중 어느 한 항에 있어서, 상기 노드는,
   상기 저장부가 데이터를 저장한 경우에는, 그 데이터와 함께 수신한 포인터 식별자가 나타내는 포인터 세트의 라이트 포인터의 값을 갱신하는 갱신부와,
   상기 라이트 포인터와 상기 리드 포인터의 값이 일치하는지 여부를 판별하는 판별부와,
   상기 판별부가, 상기 라이트 포인터와 상기 리드 포인터의 값이 일치하지 않는다고 판별한 경우에는, 그 리드 포인터가 나타내는 어드레스에 따라, 상기 기억 장치로부터 상기 데이터의 판독을 수행하는 판독부
   를 포함하는 것을 특징으로 하는 정보 처리 장치.
9. 다른 연산 장치와의 사이에서 데이터의 송수신을 수행하는 연산 장치에 있어서,
   상기 데이터를 메모리에 기입할 때의 어드레스를 나타내는 라이트 포인터와, 상기 데이터를 상기 메모리로부터 판독할 때의 어드레스를 나타내는 리드 포인터를 대응시킨 복수 개의 포인터 세트를 기억하는 기억부와,
   상기 포인터 세트를 나타내는 포인터 식별자를, 상기 데이터의 송신원이 되는 노드에 통지하는 통지부와,
   상기 데이터의 송신원이 되는 노드가 송신한 상기 데이터와, 그 데이터의 송신원이 되는 노드에 상기 통지부가 통지한 포인터 식별자를 수신한 경우에는, 그 포인터 식별자가 나타내는 포인터 세트의 라이트 포인터가 나타내는 어드레스에 따라, 그 수신한 데이터를 기억 장치에 저장하는 저장부
   를 포함하는 것을 특징으로 하는 연산 장치.
10. 각각이 프로세서 및 기억 장치를 구비하는 복수 개의 노드를 갖는 정보 처리 장치가 실행하는 정보 전송 방법에 있어서, 상기 노드는,
    상기 노드 사이에서 송수신하는 데이터를 상기 기억 장치에 기입할 때의 어드레스를 나타내는 라이트 포인터와, 상기 데이터를 상기 기억 장치로부터 판독할 때의 어드레스를 나타내는 리드 포인터를 대응시킨 복수 개의 포인터 세트를 기억하고,
    상기 포인터 세트를 나타내는 포인터 식별자를, 상기 데이터의 송신원이 되는 노드에 통지하고,
    상기 데이터의 송신원이 되는 노드로부터 상기 데이터와 그 데이터의 송신원이 되는 노드에 통지한 포인터 식별자를 수신한 경우에는, 그 포인터 식별자가 나타내는 포인터 세트의 라이트 포인터가 나타내는 어드레스에 따라, 상기 기억 장치에 그 수신한 데이터를 저장하는
    처리를 실행하는 것을 특징으로 하는 정보 전송 방법.

Images