T T A S t a n d a r d - tta.or.krLanguage)와 유사한 표준화된 자바스크립트(Javascript)...

T T

A S

t a n

d a

r d

정보통신단체표준(국문표준)

TTAK.OT-10.0390 제정일: 2015 년 12 월 16 일

병렬 처리를 위한 웹 컴퓨팅 언어-

WebCL 1.0

WebCL 1.0


TTAK.OT-10.0390 제정일: 2015 년 12 월 16 일

병렬 처리를 위한 웹 컴퓨팅 언어-

WebCL 1.0

WebCL 1.0

본 문서에 대한 저작권은 TTA 에 있으며, TTA 와 사전 협의 없이 이 문서의 전체 또는 일부를

상업적 목적으로 복제 또는 배포해서는 안 됩니다.

Copyrightⓒ Telecommunications Technology Association 2015. All Rights Reserved.


TTAK.OT-10.0390 i

서 문

1. 표준의 목적

본 표준은 CPU 와 GPU 의 병렬 처리를 가능하게 하여 웹 애플리케이션에서 연산이

많이 필요한 이미지나 비디오 처리, 데이터의 시각적 표현 및 3D 게임 등을 가능하게

하여 웹 애플리케이션의 성능을 높이는 것이 목적이다.

이를 위해서, 웹 컴퓨팅 언어(Web Computing Language)는 OpenCL(Open Computing

Language)와 유사한 표준화된 자바스크립트(Javascript) API 와 포터블 커널(portable

kernel) 프로그래밍 언어를 제공하며, 모바일, 데스크톱 및 서버 등에서 병렬 컴퓨팅을

가능하게 한다.

2. 주요 내용 요약

본 표준에는 웹 애플리케이션 개발자들이 웹 컴퓨팅 언어(Web Computing

Language)을 적용하는 데 필요한 리소스 관리, WebCL 인터페이스, WebCL 플랫폼

등과 같은 세부적인 함수에 대한 정의와 예제가 포함되어 있으며, Web 을 사용하는 데

필요한 OpenCL(Open Computing Language)과 관련된 내용도 포함하고 있다.

첫 번째로 기본 유형, 예외, 리소스 관리, 콜백(callback) 과 같은 WebCL 표준에 대한

규정에 대해서 정의하였고, 두 번째로 WebCL 객체와 인터페이스(interface),

장치(device), 컨텍스트(context) 등과 같이 구체적으로 객체를 사용하기 위한 방법과

확장, 보안관련 사항들이 포함되어 있다. 각 항목에는 함수에 대한 자세한 설명과

구체적인 사용 예제가 같이 포함되어 있다.

3. 표준 적용 산업 분야 및 산업에 미치는 영향

최근 들어 브라우저 기반의 웹 애플리케이션 사용이 늘어나고 있고, 게임, 비디오,

오디오 등 다양한 분야로 범위가 확대됨에 따라 연산이 많은 웹 애플리케이션의 개발

필요성과 수요가 늘어나고 있다. 본 표준은 이기종 간에 병렬프로그램이 가능하도록

하여 웹 브라우저 기반의 고성능 애플리케이션을 개발하는 산업 전반에 큰 도움을 줄 수

있을 것으로 기대된다.

4. 참조 표준(권고)


TTAK.OT-10.0390 ii

4.1. 국외 표준(권고)

- Khronos Group, WebCL Specification 1.0, 2014.

4.2. 국내 표준

- 해당 사항 없음.

5. 참조 표준(권고)과의 비교

5.1. 참조 표준(권고)과의 관련성

본 표준은 크로노스그룹의 WebCL Specification 1.0 을 참조하여 번역하였다.

5.2. 참조한 표준(권고)과 본 표준의 비교표

TTAK.OT-10.0390 WebCL Specification 1.0 비고

1. 개요 Introduction 추가

2. 표준의 구성 및 범위 Abstraction 추가

3. 참조 표준(권고) 8.References 동일

4. 용어 정의 및 약어 - 추가

5. 규칙 2. Conventions 동일(번역)

6. 인터페이스 3. Interface 동일(번역)

7. 확장 4. Extension 동일(번역)

8. 보안 및 로버스트니스 5. Security and Robustness 동일(번역)

9. 개발노트 6. Implementation notes 동일(번역)

10. WebCL 과 OpenCL 1.1 의

차이점

7. Differences between WebCL

and OpenCL 1.1 동일(번역)

6. 지식 재산권 관련 사항

본 표준의 ‘지식 재산권 확약서’ 제출 현황은 TTA 웹사이트에서 확인할 수 있다.

※본 표준을 이용하는 자는 이용함에 있어 지식 재산권이 포함되어 있을 수 있으므로,

확인 후 이용한다.

※본 표준과 관련하여 접수된 확약서 이외에도 지식 재산권이 존재할 수 있다.


TTAK.OT-10.0390 iii

7. 시험 인증 관련 사항

7.1. 시험 인증 대상 여부


7.2. 시험 표준 제정 현황


8. 표준의 이력 정보

8.1. 표준의 이력

판수 제정‧개정일 제정‧개정 내역

제 1 판 2015.12.16. 제정

TTAK.OT-10.0390

8.2. 주요 개정 사항



TTAK.OT-10.0390 iv

Preface

1. Purpose of Standard

The standard is to define WebCL (Web Computing Language). WebCL is a JavaScript

binding to the Khronos OpenCL standard for heterogeneous parallel computing. It

enables web applications to harness GPU and multi-core CPU parallel processing from

within a Web browser, enabling significant acceleration of computationally intensive

applications, such as image and video processing, data visualization, and 3D games.

WebCL (Web Computing Language), which is similarly OpenCL (Open Computing

Language), provides standardized JavaScript API and portable kernel programming

language, enables parallel computing on mobile, desktop, and server systems.

2. Summary of Contents

The standard includes specific functions and examples of resource management,

WebCL interface, WebCL platform to use Web Computing Language(WebCL) for Web

developers. First, it defines Web Computing Languages standards such as basic type,

resource management, and callback. Second, it defines an extension, and security

methods for using the WebCL object, interface, device, and context. The standard

shows specific use cases and detailed description of each function.

3. Applicable Fields of Industry and its Effect

With the popularity of web-centric platforms, there is a need to leverage high-

performance parallel processing to accelerate compute-intensive web applications.

Such applications include, for example, data visualization, image and video processing,

3D gaming, computational photography, computer vision, and cryptography. By

providing application developers with a standardized JavaScript API and a portable

kernel programming language, Web Computing Language (WebCL) enables parallel

computing on heterogeneous multicore hardware across a breadth of devices,

including mobile, desktop, and server. The Web Computing Language(WebCL) API and

kernel language are designed to be substantially similar to those of OpenCL (Open

Computing Language), and implementable on top of a conformant OpenCL driver.


TTAK.OT-10.0390 v

4. Reference Standards (Recommendations)

4.1. International Standards (Recommendations)


4.2. Domestic Standards

- None

5. Relationship to Reference Standards(Recommendations)

5.1. Relationship of Reference Standards(Recommendations)

This standard is fully referred from “Khronos Group WebCL Specification 1.0”

5.2. Differences between Reference Standard(Recommendation) and this Standard

TTAK.OT-10.0390 WebCL Specification 1.0 Remarks

1. Introduction Introduction Added

2. Scope of this standard Abstraction Added

3. Reference Standards 8. References Added

4. Definitions and Terms - Added

5. Conventions 2. Conventions Equivalent

6. Interface 3. Interface Equivalent

7. Extensions 4. Extension Equivalent

8. Security and Robustness 5. Security and Robustness Equivalent

9. Implementation notes 6. Implementation notes Equivalent

7. Differences between WebCL

and OpenCL 1.1 Equivalent


TTAK.OT-10.0390 vi

6. Statement of Intellectual Property Rights

IPRs related to the present document may have been declared to TTA. The

information pertaining to these IPRs, if any, is available on the TTA Website.

No guarantee can be given as to the existence of other IPRs not referenced on the

TTA website.

And, please make sure to check before applying the standard.

7. Statement of Testing and Certification

7.1. Object of Testing and Certification

- None

7.2. Standards of Testing and Certification

- None

8. History of Standard

8.1. Change History

Edition Issued date Outline

The 1st edition 2015.12.16. Established

TTAK.OT-10.0390

8.2. Revisions

- None


TTAK.OT-10.0390 vii

목 차

1. 개 요 ······························································································· 1

2. 표준의 구성 및 범위 ············································································· 1

3. 참조 표준(권고) ·················································································· 1

4. 용어 정의 및 약어 ················································································ 2

5. 규칙 ······························································································· 2

5.1. 기본 유형 ···················································································· 2

5.2. 예외 조건들 ·················································································· 3

5.3. 리소스 관리 ·················································································· 3

5.4. 동시성 ························································································ 4

5.4. 콜백 ··························································································· 4

6. 인터페이스 ························································································· 5

6.1. WebCL ······················································································· 5

6.2. WebCL 플랫폼 ············································································· 13

6.3. WebCL 디바이스 ·········································································· 15

6.4. WebCL 컨텍스트(context) ······························································· 17

6.5. WebCLCommandQueur ·································································· 20

6.6. WebCLMemoryObject ···································································· 33

6.7. WebCLSampler ············································································ 34

6.8. WebCLProgram ············································································ 35

6.9. WebCLKernel ·············································································· 37

6.10. WebCLUserEvent ········································································ 40

7. 확장 ······························································································· 42

8. 보안 및 로버스트니스 ·········································································· 43

8.1. 범위를 벗어난 메모리 접근 ···························································· 43

8.2. 메모리 초기화 ············································································ 43


TTAK.OT-10.0390 viii

8.3. 서비스 거부 ·············································································· 44

9. 개발 노트 ························································································ 44

10. WebCL과 OpenCL 1.1의 차이점 ···························································· 45


TTAK.OT-10.0390 ix

Contents

1. Introduction ························································································ 1

2. Constitution and Scope ·········································································· 1

3. Reference Standards(Recommendations) ··················································· 1

4. Terms Definition and Abbreviations ··························································· 2

5. Conventions ······················································································ 2

5.1. Basic types ················································································· 2

5.2. Exceptions ··················································································· 3

5.3. Resource Management ···································································· 3

5.4. Concurrency ················································································· 4

5.5. Callback ······················································································ 4

6. Interface ···························································································· 5

6.1. WebCL ······················································································· 5

6.2. WebCL Platform ··········································································· 13

6.3. WebCL Device ············································································· 15

6.4. WebCL Context ············································································ 17

6.5. WebCL Command Queur ································································ 20

6.6. WebCL Memory Object ·································································· 33

6.7. WebCL Sampler ··········································································· 34

6.8. WebCL Program ··········································································· 35

6.9. WebCL Kernel ············································································· 37

6.10. WebCL User Event ······································································ 40

7. Extensions ······················································································· 42

8. Security and Robustness ······································································ 43

8.1. Out-of-Bounds Memory Access ······················································ 43

8.2. Memory Initialization ···································································· 43


TTAK.OT-10.0390 x

8.3. Denial of Service ········································································· 44

9. Implementation Notes ········································································ 44

10. Differences between WebCL and OpenCL 1.1 ··········································· 45


TTAK.OT-10.0390 １

병렬 처리를 위한 웹 컴퓨팅 언어-WebCL 1.0

(WebCL 1.0)

1. 개요

웹 중심의 플랫폼들이 대중화되면서, 많은 연산이 필요한 웹 애플리케이션들을

가속하기 위하여 고성능의 병렬 프로세싱을 사용할 필요성이 대두됬었다. 이에는 데이터

가시화(visualization), 영상 및 동영상 처리, 3D 게임, 사진의 사진의 가공(computational

photography), 컴퓨터 비전(computer vision), 그리고 암호화 등과 같은

애플리케이션들이 포함한다. 표준화된 자바스크립트(JavaScript) API와 포터블

커널(portable kernel) 프로그래밍 언어를 애플리케이션 개발자들에게 제공하여, 웹

컴퓨팅 언어(WebCL)는 모바일, 데스크톱 및 서버와 같은 장치들의 활성화에 걸쳐서

이기종 간 멀티코어(multi-core) 하드웨어에서 병렬 컴퓨팅이 가능하게 한다. 웹 컴퓨팅

언어(WebCL) API와 커널(kernel) 언어는 OpenCL(Open Computing Language) 과

근본적으로 유사하며, 적합한 OpenCL(Open Computing Language) 구동기(driver)의

최상위에 구현할 수 있도록 설계되었다.

2. 표준의 구성 및 범위

본 표준에는 웹 애플리케이션 개발자들이 웹 컴퓨팅 언어(WebCL)를 적용하는 데

필요한 리소스(resource) 관리, 웹 컴퓨팅 언어(WebCL) 인터페이스, 웹 컴퓨팅

언어(WebCL) 플랫폼 등과 같은 세부적인 함수에 대해서 정의와 예제를 포함하고

있으며, 웹을 사용하는 데 있어서 필요한 OpenCL(Open Computing Language)과

관련된 내용도 포함하고 있으며, 장별로 개발자의 이해를 돕기 위한 예제를 포함하고

있다.

기본 유형, 예외 조건, 리소스 관리, 자바스크립트와 동시 사용, 콜백 등과 같은

웹 컴퓨팅 언어(WebCL) 사용에 따른 기본 규정

웹 컴퓨팅 언어(WebCL) 사용을 위한 인터페이스

웹 컴퓨팅 언어(WebCL)의 확장에 대한 정의

보안 및 로버스트니스(robustness) 요구사항

OpenCL 1.1과의 차이점

3. 참조 표준(권고)


TTAK.OT-10.0390 ２

3.1. 국외 표준(권고)


3.2. 국내 표준


4. 용어 정의 및 약어

4.1. 약어

WebCL Web Computing Language

OpenCL Open Computing Language

WebGL Web Graphics Language

5. 규칙(Conventions)

5.1. 기본 유형

다음의 기본 유형이 본 문서에서 사용되었다.

typedef Boolean CLboolean;

typedef long Clint; // 32-bit signed integer

typedef long long CLlong; // 64-bit signed integer

typedef unsigned long CLuint; // 32-bit unsigned integer

typedef unsigned long long CLulong; // 64-bit unsigned integer

typedef const unsigned long CLenum; // WebCL_DEVICE_TYPE_GPU 와 같은 열거형이 사용됨

WebCL 숫자 값을 입력받은 특정 기능을 구현함에 있어서 만약 정해진 범위의 밖의

숫자를 입력할 경우에는 정의된 동작이 일어나지 않는 것을 확인해야 한다. 필요한

경우에는, 구현할 때는 클램프(clamp)나 모듈로 오퍼레이터(modulo operator)를

사용하여 요청된 자바스크립트 숫자를 허용 범위에 맞추거나 반복적으로 예외로 처리할

수 있다.


TTAK.OT-10.0390 ３

5.2. 예외 조건들

WebCL 메소드(method)는 OpenCL에서 반환 값으로 에러 코드를 예외적으로 반환할

수 있다. 이 예외는 메소드(method) 문서에 있는 각 메소드(method)에 의해서 전달된

것일 것이다. 추가적으로, 거의 모든 메소드(method)는 OUT_OF_RESOURCE,

OUT_OF_HOST_MEMORY, 또는 WebCL 에 한정된

WEBCL_IMPLEMENTATION_FAILURE를 전달하며, 이것들은 각각 목록화되어 있지 않다.

객체가 해제된 뒤에 어떤 기능(release 제외)을 호출하면, TYPE이 CONTEXT,

COMMAND_QUEUE, MEM_OBJECT, SAMPLER, PROGRAM, KERNEL, 또는 EVENT에서

INVALID_TYPE을 전송한다. 이러한 예외들은 메소드(method) 설명에서 따로 목록으로

되어 있지 않다.

Exception WebCLException : DOMException {

DOMString name; // 숫자 에러 코드를 나타내는 문자열. 예를 들어서, “INVALID_VALUE”

DOMString? Message; // 예외에 의해서 발생한 것을 명시적으로 표현

};

Name 과 message 필드 둘 다 구현에 의한 WebCLException 중 하나를 나타내지만,

메시지는 null 이다.

5.3. 리소스 관리

각각 동적으로 WebCL 객체는 객체에 의해서 사용된 목록을 해제하는 release

메소드(method)를 가진다. 이것은 삭제되거나 확보된(garbage collected) 객체를

발생시키지는 않으며, 이것은 남아 있기는 하지만, 예외 처리를 발생시켜 사용하려 할

것이다. 이미 해제된 객체를 다시 해제하기를 시도하는 것은 무시될 것이다.

사용의 편리를 위해서, WebCL과 WebCLContext 클래스는 그들로부터 생성된 다른

WebCL 객체만이 아니라 컨텍스트(context)를 해제하는 추가적인 releaseAll 기능을

포함하고 있다. 해제 방법에 대한 사용 방법이나 동작은 아래 예제에 보였다.

예제 1

var ctx1 = webcl.createContext(...);



var A = ctx1.createBuffer(...);


TTAK.OT-10.0390 ４

var B = ctx2.createBuffer(...);

ctx1.release(); // ctx1를 해제하지만, buffer A는 아님

ctx2.releaseAll(); // ctx2와 buffer B를 해제하고 and buffer B

A.release(); // buffer A를 해제

B.release(); // does nothing: B가 이미 해제되었으면, 아무것도 하지 않음

var C = ctx1.createBuffer(...); // 예외: ctx1가 더 이상 유효하지 않음

webcl.releaseAll(); // ctx3를 해제

애플리케이션은 대신에 자바스크립터 가비지 컬렉터 (garbage collector)에 의존하는

대신에 객체가 더 이상 필요가 없으면 모든 WebCL 객체를 해제하기를 강력하게

권고한다. 이것은 가비지 컬렉터 (garbage collector)가 일반적으로 범위안에 있지 않은

객체를 다시 사용할 때 보장을 하지 못하기 때문에 필요하다.

글로벌 document 객체가 범위를 벗어날 때, WebCL 구현은 모든 남아 있는 WebCL

객체 명확하지 않게(implicitly) release를 호출하여야 한다.

5.4. 동시성(concurrency)

구현에 따라, WebCL 조작은 자바스크립트와 동시에 동작할 것이다. 특별히, 이것은

애플리케이션에 대해서 WebCLMemoryObject나 또는 이것에 비동기적으로 복사되는

동안에 ArrayBuffer의 수정이 가능하다. 버퍼의 콘텐츠의 손상을 막기 위하여,

애플리케이션은 근접한 WebCL 명령 큐가 종료될 때까지 비동기 읽기/쓰기 상태에 있는

ArrayBuffer는 수정하지 말아야 한다.

5.5. 콜백(Callback)

WebCL을 비동기적이나 동기적으로 실행하는 장시간 동작 기능을 허가한다. 비동기

상태는 만약 사용자 정의된 콜백(callback) 기능이 이 기능에 대한 실행인자로 주어져서

사용된다. 비동기 상태를 강력하게 권고하며, 자바스크립트의 메인 스레드(main

thread)가 차단되는 것을 피할 수 있다. 만약 콜백(callback) 기능이 연속적으로 해제된

WebCL 객체와 관련되었다면, 콜백(Callback)은 더 이상 발생되지 않는다. 콜백(callback)

기능의 시그너처(signature)는 아래와 같다.

Callback WebCLCallback = void (optional WebCLEvent event);


TTAK.OT-10.0390 ５

메인 스레드(main thread)의 차단을 피하고자, 콜백(callback) 기능은 빠르게

완료되어야 하며, 장시간 실행하는 기능으로 호출되면 안 된다. 어떤 WebCL 기능이

명확하게 금지되었다면, 만약 콜백(callback)으로부터 발생하였다면 예외 처리로

INVALID_OPERATION 이 발생한다. 금지된 기능들은 createContext,

createCommandQueue 를 포함하여, finish, waitForEvents, build, 그리고 enqueue

{read, Write} {Buffer, BefferRect, Image} 폼(form)을 차단한다.

6. 인터페이스

6.1. WebCL

WebCL API 는 글로벌 window 네임스페이스(namespace)에 속하는 싱글톤(singleton)

webcl 객체를 통해서 접근이 가능하다. Webcl 객체는 WebCL 인터페이스를 구현하고,

컴퓨팅 컨텍스트(computing context)를 생성하는데 필요한 기능을 제공하고, 가능한

WebCL 플랫폼과 확장을 요청한다.

partial interface Window { readonly attribute WebCL webcl; };

interface WebCL {

sequence<WebCLPlatform> getPlatforms();

WebCLContext createContext(optional CLenum deviceType);

WebCLContext createContext(WebCLPlatform platform, optional CLenum deviceType);

WebCLContext createContext(WebCLDevice device);

WebCLContext createContext(sequence<WebCLDevice> devices);

sequence<DOMString>? getSupportedExtensions();

CLboolean enableExtension(DOMString extensionName);

void waitForEvents(sequence<WebCLEvent> eventWaitList,

optional WebCLCallback whenFinished);

void releaseAll();

/* Error Codes */

CLint SUCCESS= 0;

CLint DEVICE_NOT_FOUND = -1;

CLint DEVICE_NOT_AVAILABLE = -2;

CLint COMPILER_NOT_AVAILABLE = -3

CLint MEM_OBJECT_ALLOCATION_FAILURE = -4

CLint OUT_OF_RESOURCES = -5

CLint OUT_OF_HOST_MEMORY = -6

CLint PROFILING_INFO_NOT_AVAILABLE = -7

CLint MEM_COPY_OVERLAP = -8;

CLint IMAGE_FORMAT_MISMATCH = -9;

CLint IMAGE_FORMAT_NOT_SUPPORTED = -10;

CLint BUILD_PROGRAM_FAILURE = -11;

CLint MAP_FAILURE = -12


TTAK.OT-10.0390 ６

CLint MISALIGNED_SUB_BUFFER_OFFSET = -13

CLint EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST = -14;

CLint INVALID_VALUE = -30;

CLint INVALID_DEVICE_TYPE = -31;

CLint INVALID_PLATFORM = -32;

CLint INVALID_DEVICE = -33;

CLint INVALID_CONTEXT = -34;

CLint INVALID_QUEUE_PROPERTIES = -35;

CLint INVALID_COMMAND_QUEUE = -36;

CLint INVALID_HOST_PTR = -37;

CLint INVALID_MEM_OBJECT = -38;

CLint INVALID_IMAGE_FORMAT_DESCRIPTOR = -39;

CLint INVALID_IMAGE_SIZE = -40;

CLint INVALID_SAMPLER = -41;

CLint INVALID_BINARY = -42;

CLint INVALID_BUILD_OPTIONS = -43;

CLint INVALID_PROGRAM = -44;

CLint INVALID_PROGRAM_EXECUTABLE = -45;

CLint INVALID_KERNEL_NAME = -46;

CLint INVALID_KERNEL_DEFINITION = -47;

CLint INVALID_KERNEL = -48;

CLint INVALID_ARG_INDEX = -49;

CLint INVALID_ARG_VALUE = -50;

CLint INVALID_ARG_SIZE = -51;

CLint INVALID_KERNEL_ARGS = -52;

CLint INVALID_WORK_DIMENSION = -53;

CLint INVALID_WORK_GROUP_SIZE = -54;

CLint INVALID_WORK_ITEM_SIZE = -55;

CLint INVALID_GLOBAL_OFFSET = -56;

CLint INVALID_EVENT_WAIT_LIST = -57;

CLint INVALID_EVENT = -58;

CLint INVALID_OPERATION = -59;

//CLint INVALID_GL_OBJECT = -60; // moved to extension

CLint INVALID_BUFFER_SIZE = -61;

//CLint INVALID_MIP_LEVEL = -62; // moved to extension

CLint INVALID_GLOBAL_WORK_SIZE = -63;

CLint INVALID_PROPERTY = -64;

/* cl_bool */

CLenum FALSE = 0;

CLenum TRUE = 1;

/* cl_platform_info */

CLenum PLATFORM_PROFILE = 0x0900;

CLenum PLATFORM_VERSION = 0x0901;

CLenum PLATFORM_NAME = 0x0902;

CLenum PLATFORM_VENDOR = 0x0903;

CLenum PLATFORM_EXTENSIONS = 0x0904;

/* cl_device_type - bitfield */

CLenum DEVICE_TYPE_DEFAULT = 0x1;

CLenum DEVICE_TYPE_CPU = 0x2;

CLenum DEVICE_TYPE_GPU = 0x4;

CLenum DEVICE_TYPE_ACCELERATOR = 0x8;

CLenum DEVICE_TYPE_ALL = 0xFFFFFFFF;

/* cl_device_info */

CLenum DEVICE_TYPE = 0x1000;

CLenum DEVICE_VENDOR_ID = 0x1001;

CLenum DEVICE_MAX_COMPUTE_UNITS = 0x1002;

CLenum DEVICE_MAX_WORK_ITEM_DIMENSIONS = 0x1003;


TTAK.OT-10.0390 ７

CLenum DEVICE_MAX_WORK_GROUP_SIZE = 0x1004;

CLenum DEVICE_MAX_WORK_ITEM_SIZES = 0x1005;

CLenum DEVICE_PREFERRED_VECTOR_WIDTH_CHAR = 0x1006;

CLenum DEVICE_PREFERRED_VECTOR_WIDTH_SHORT = 0x1007;

CLenum DEVICE_PREFERRED_VECTOR_WIDTH_INT = 0x1008;

CLenum DEVICE_PREFERRED_VECTOR_WIDTH_LONG = 0x1009;

CLenum DEVICE_PREFERRED_VECTOR_WIDTH_FLOAT = 0x100A;

//CLenum DEVICE_PREFERRED_VECTOR_WIDTH_DOUBLE = 0x100B; // moved to extension

CLenum DEVICE_MAX_CLOCK_FREQUENCY = 0x100C;

CLenum DEVICE_ADDRESS_BITS = 0x100D;

CLenum DEVICE_MAX_READ_IMAGE_ARGS = 0x100E;

CLenum DEVICE_MAX_WRITE_IMAGE_ARGS = 0x100F;

CLenum DEVICE_MAX_MEM_ALLOC_SIZE = 0x1010;

CLenum DEVICE_IMAGE2D_MAX_WIDTH = 0x1011;

CLenum DEVICE_IMAGE2D_MAX_HEIGHT = 0x1012;

CLenum DEVICE_IMAGE3D_MAX_WIDTH = 0x1013;

CLenum DEVICE_IMAGE3D_MAX_HEIGHT = 0x1014;

CLenum DEVICE_IMAGE3D_MAX_DEPTH = 0x1015;

CLenum DEVICE_IMAGE_SUPPORT = 0x1016;

CLenum DEVICE_MAX_PARAMETER_SIZE = 0x1017;

CLenum DEVICE_MAX_SAMPLERS = 0x1018;

CLenum DEVICE_MEM_BASE_ADDR_ALIGN = 0x1019;

//CLenum DEVICE_MIN_DATA_TYPE_ALIGN_SIZE = 0x101A; // removed deprecated in

OpenCL 1.2

CLenum DEVICE_SINGLE_FP_CONFIG = 0x101B;

CLenum DEVICE_GLOBAL_MEM_CACHE_TYPE = 0x101C;

CLenum DEVICE_GLOBAL_MEM_CACHELINE_SIZE = 0x101D;

CLenum DEVICE_GLOBAL_MEM_CACHE_SIZE = 0x101E;

CLenum DEVICE_GLOBAL_MEM_SIZE = 0x101F;

CLenum DEVICE_MAX_CONSTANT_BUFFER_SIZE = 0x1020;

CLenum DEVICE_MAX_CONSTANT_ARGS = 0x1021;

CLenum DEVICE_LOCAL_MEM_TYPE = 0x1022;

CLenum DEVICE_LOCAL_MEM_SIZE = 0x1023;

CLenum DEVICE_ERROR_CORRECTION_SUPPORT = 0x1024;

CLenum DEVICE_PROFILING_TIMER_RESOLUTION = 0x1025;

CLenum DEVICE_ENDIAN_LITTLE = 0x1026;

CLenum DEVICE_AVAILABLE = 0x1027;

CLenum DEVICE_COMPILER_AVAILABLE = 0x1028;

CLenum DEVICE_EXECUTION_CAPABILITIES = 0x1029;

CLenum DEVICE_QUEUE_PROPERTIES = 0x102A;

CLenum DEVICE_NAME = 0x102B;

CLenum DEVICE_VENDOR = 0x102C;

CLenum DRIVER_VERSION = 0x102D;

CLenum DEVICE_PROFILE = 0x102E;

CLenum DEVICE_VERSION = 0x102F;

CLenum DEVICE_EXTENSIONS = 0x1030;

CLenum DEVICE_PLATFORM = 0x1031;

//CLenum DEVICE_DOUBLE_FP_CONFIG = 0x1032; // moved to extension

//CLenum DEVICE_HALF_FP_CONFIG = 0x1033; // moved to extension

//CLenum DEVICE_PREFERRED_VECTOR_WIDTH_HALF = 0x1034; // moved to extension

CLenum DEVICE_HOST_UNIFIED_MEMORY = 0x1035;

CLenum DEVICE_NATIVE_VECTOR_WIDTH_CHAR = 0x1036;

CLenum DEVICE_NATIVE_VECTOR_WIDTH_SHORT = 0x1037;

CLenum DEVICE_NATIVE_VECTOR_WIDTH_INT = 0x1038;

CLenum DEVICE_NATIVE_VECTOR_WIDTH_LONG = 0x1039;

CLenum DEVICE_NATIVE_VECTOR_WIDTH_FLOAT = 0x103A;

//CLenum DEVICE_NATIVE_VECTOR_WIDTH_DOUBLE = 0x103B; // moved to extension

//CLenum DEVICE_NATIVE_VECTOR_WIDTH_HALF = 0x103C; // moved to extension

CLenum DEVICE_OPENCL_C_VERSION = 0x103D;

/* cl_device_fp_config - bitfield */


TTAK.OT-10.0390 ８

CLenum FP_DENORM = 0x1;

CLenum FP_INF_NAN = 0x2;

CLenum FP_ROUND_TO_NEAREST = 0x4;

CLenum FP_ROUND_TO_ZERO = 0x8;

CLenum FP_ROUND_TO_INF = 0x10;

CLenum FP_FMA = 0x20;

CLenum FP_SOFT_FLOAT = 0x40;

/* cl_device_mem_cache_type */

CLenum NONE = 0x0;

CLenum READ_ONLY_CACHE = 0x1;

CLenum READ_WRITE_CACHE = 0x2;

/* cl_device_local_mem_type */

CLenum LOCAL = 0x1;

CLenum GLOBAL = 0x2;

/* cl_device_exec_capabilities - bitfield */

CLenum EXEC_KERNEL = 0x1;

//CLenum EXEC_NATIVE_KERNEL = 0x2; // disallowed

/* cl_command_queue_properties - bitfield */

CLenum QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABLE = 0x1;

CLenum QUEUE_PROFILING_ENABLE = 0x2;

/* cl_context_info */

//CLenum CONTEXT_REFERENCE_COUNT = 0x1080; // disallowed

CLenum CONTEXT_DEVICES = 0x1081;

//CLenum CONTEXT_PROPERTIES = 0x1082; // disallowed; no context

properties in WebCL

CLenum CONTEXT_NUM_DEVICES = 0x1083;

/* cl_context_properties */

//CLenum CONTEXT_PLATFORM = 0x1084; // disallowed

/* cl_command_queue_info */

CLenum QUEUE_CONTEXT = 0x1090;

CLenum QUEUE_DEVICE = 0x1091;

//CLenum QUEUE_REFERENCE_COUNT = 0x1092; // disallowed

CLenum QUEUE_PROPERTIES = 0x1093;

/* cl_mem_flags - bitfield */

CLenum MEM_READ_WRITE = 0x1;

CLenum MEM_WRITE_ONLY = 0x2;

CLenum MEM_READ_ONLY = 0x4;

/* cl_channel_order */

CLenum R = 0x10B0;

CLenum A = 0x10B1;

CLenum RG = 0x10B2;

CLenum RA = 0x10B3;

CLenum RGB = 0x10B4;

CLenum RGBA = 0x10B5;

CLenum BGRA = 0x10B6;

CLenum ARGB = 0x10B7;

CLenum INTENSITY = 0x10B8;

CLenum LUMINANCE = 0x10B9;

CLenum Rx = 0x10BA;

CLenum RGx = 0x10BB;

CLenum RGBx = 0x10BC;


TTAK.OT-10.0390 ９

/* cl_channel_type */

CLenum SNORM_INT8 = 0x10D0;

CLenum SNORM_INT16 = 0x10D1;

CLenum UNORM_INT8 = 0x10D2;

CLenum UNORM_INT16 = 0x10D3;

CLenum UNORM_SHORT_565 = 0x10D4;

CLenum UNORM_SHORT_555 = 0x10D5;

CLenum UNORM_INT_101010 = 0x10D6;

CLenum SIGNED_INT8 = 0x10D7;



CLenum UNSIGNED_INT8 = 0x10DA;

CLenum UNSIGNED_INT16 = 0x10DB;

CLenum UNSIGNED_INT32 = 0x10DC;

CLenum HALF_FLOAT = 0x10DD;

CLenum FLOAT = 0x10DE;

/* cl_mem_object_type */

CLenum MEM_OBJECT_BUFFER = 0x10F0;

CLenum MEM_OBJECT_IMAGE2D = 0x10F1;

CLenum MEM_OBJECT_IMAGE3D = 0x10F2;

/* cl_mem_info */

CLenum MEM_TYPE = 0x1100;

CLenum MEM_FLAGS = 0x1101;

CLenum MEM_SIZE = 0x1102;

//CLenum MEM_HOST_PTR = 0x1103; // disallowed

//CLenum MEM_MAP_COUNT = 0x1104; // disallowed

//CLenum MEM_REFERENCE_COUNT = 0x1105; // disallowed

CLenum MEM_CONTEXT = 0x1106;

CLenum MEM_ASSOCIATED_MEMOBJECT = 0x1107;

CLenum MEM_OFFSET = 0x1108;

/* cl_image_info */

CLenum IMAGE_FORMAT = 0x1110;

CLenum IMAGE_ELEMENT_SIZE = 0x1111;

CLenum IMAGE_ROW_PITCH = 0x1112;

CLenum IMAGE_WIDTH = 0x1114;

CLenum IMAGE_HEIGHT = 0x1115;

/* cl_addressing_mode */

//CLenum ADDRESS_NONE = 0x1130; // disallowed

CLenum ADDRESS_CLAMP_TO_EDGE = 0x1131;

CLenum ADDRESS_CLAMP = 0x1132;

CLenum ADDRESS_REPEAT = 0x1133;

CLenum ADDRESS_MIRRORED_REPEAT = 0x1134;

/* cl_filter_mode */

CLenum FILTER_NEAREST = 0x1140;

CLenum FILTER_LINEAR = 0x1141;

/* cl_sampler_info */

//CLenum SAMPLER_REFERENCE_COUNT = 0x1150; // disallowed

CLenum SAMPLER_CONTEXT = 0x1151;

CLenum SAMPLER_NORMALIZED_COORDS = 0x1152;

CLenum SAMPLER_ADDRESSING_MODE = 0x1153;

CLenum SAMPLER_FILTER_MODE = 0x1154;

/* cl_map_flags - bitfield */

//CLenum MAP_READ = 0x1; // disallowed

//CLenum MAP_WRITE = 0x2; // disallowed


TTAK.OT-10.0390 １０

/* cl_program_info */

//CLenum PROGRAM_REFERENCE_COUNT = 0x1160; // disallowed

CLenum PROGRAM_CONTEXT = 0x1161;

CLenum PROGRAM_NUM_DEVICES = 0x1162;

CLenum PROGRAM_DEVICES = 0x1163;

CLenum PROGRAM_SOURCE = 0x1164;

//CLenum PROGRAM_BINARY_SIZES = 0x1165; // disallowed

//CLenum PROGRAM_BINARIES = 0x1166; // disallowed

/* cl_program_build_info */

CLenum PROGRAM_BUILD_STATUS = 0x1181;

CLenum PROGRAM_BUILD_OPTIONS = 0x1182;

CLenum PROGRAM_BUILD_LOG = 0x1183;

/* cl_build_status */

CLint BUILD_SUCCESS = 0;

CLint BUILD_NONE = -1;

CLint BUILD_ERROR = -2;

CLint BUILD_IN_PROGRESS = -3;

/* cl_kernel_info */

CLenum KERNEL_FUNCTION_NAME = 0x1190;

CLenum KERNEL_NUM_ARGS = 0x1191;

//CLenum KERNEL_REFERENCE_COUNT = 0x1192; // disallowed

CLenum KERNEL_CONTEXT = 0x1193;

CLenum KERNEL_PROGRAM = 0x1194;

/* cl_kernel_work_group_info */

CLenum KERNEL_WORK_GROUP_SIZE = 0x11B0;

CLenum KERNEL_COMPILE_WORK_GROUP_SIZE = 0x11B1;

CLenum KERNEL_LOCAL_MEM_SIZE = 0x11B2;

CLenum KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE = 0x11B3;

CLenum KERNEL_PRIVATE_MEM_SIZE = 0x11B4

/* cl_event_info */

CLenum EVENT_COMMAND_QUEUE = 0x11D0;

CLenum EVENT_COMMAND_TYPE = 0x11D1;

//CLenum EVENT_REFERENCE_COUNT = 0x11D2; // disallowed

CLenum EVENT_COMMAND_EXECUTION_STATUS = 0x11D3;

CLenum EVENT_CONTEXT = 0x11D4;

/* cl_command_type */

CLenum COMMAND_NDRANGE_KERNEL = 0x11F0;

CLenum COMMAND_TASK = 0x11F1;

//CLenum COMMAND_NATIVE_KERNEL = 0x11F2; // disallowed

CLenum COMMAND_READ_BUFFER = 0x11F3;

CLenum COMMAND_WRITE_BUFFER = 0x11F4;

CLenum COMMAND_COPY_BUFFER = 0x11F5;

CLenum COMMAND_READ_IMAGE = 0x11F6;

CLenum COMMAND_WRITE_IMAGE = 0x11F7;

CLenum COMMAND_COPY_IMAGE = 0x11F8;

CLenum COMMAND_COPY_IMAGE_TO_BUFFER = 0x11F9;

CLenum COMMAND_COPY_BUFFER_TO_IMAGE = 0x11FA;

//CLenum COMMAND_MAP_BUFFER = 0x11FB; // disallowed

//CLenum COMMAND_MAP_IMAGE = 0x11FC; // disallowed

//CLenum COMMAND_UNMAP_MEM_OBJECT = 0x11FD; // disallowed

CLenum COMMAND_MARKER = 0x11FE;

//CLenum COMMAND_ACQUIRE_GL_OBJECTS = 0x11FF; // moved to extension

//CLenum COMMAND_RELEASE_GL_OBJECTS = 0x1200; // moved to extension

CLenum COMMAND_READ_BUFFER_RECT = 0x1201;


TTAK.OT-10.0390 １１

CLenum COMMAND_WRITE_BUFFER_RECT = 0x1202;

CLenum COMMAND_COPY_BUFFER_RECT = 0x1203;

CLenum COMMAND_USER = 0x1204;

/* command execution status */

CLenum COMPLETE = 0x0;

CLenum RUNNING = 0x1;

CLenum SUBMITTED = 0x2;

CLenum QUEUED = 0x4;

/* cl_profiling_info */

CLenum PROFILING_COMMAND_QUEUED = 0x1280;

CLenum PROFILING_COMMAND_SUBMIT = 0x1281;

CLenum PROFILING_COMMAND_START = 0x1282;

CLenum PROFILING_COMMAND_END = 0x1283;

};

sequence<WebCLPlatform> getPlatforms() (OpenCL 1.1 §4.1, clGetPlatformIDs)

이 시스템에서 가능한 WebCL 플랫폼을 가져옴

WebCLContext createContext(optional CLenum deviceType = WebCL.DEVICE_TYPE_DEFAULT)

(OpenCL 1.1 §4.3, clCreateContextFromType)

가능하다면, 주어진 디바이스 유형에 대한 WebCL 컨텍스트(context)를 새롭게 생성하여 반환함.

가능한 deviceType 값은 아래 표에 나열하였음

deviceType 설명

DEVICE_TYPE_CPU 싱글코어 또는 멀티코어 CPU, 일반적으로 호스트

프로세스

DEVICE_TYPE_GPU 그래픽 프로세싱 유니트, 일반적으로 WebGL에서 사용

DEVICE_TYPE_ACCELERATOR 사용한 OpenGL 가속기

DEVICE_TYPE_DEFAULT 시스템의 디폴트 디바이스

Exceptions:

INVALID_OPERATION – 이 기능이 WebCLCallback에서 요청될 경우 INVALID_DEVICE_TYPE – deviceType에 DEVICE_TYPE 사용하지 않은 경우 DEVICE_NOT_FOUND – deviceType이 발견된 플랫폼에서 일치하는 단말기가 없을 경우 DEVICE_NOT_AVAILABLE – 플랫폼에서 사용가능한 deviceType과 일치하는 단말기가 없을

경우

WebCLContext createContext (WebCLPlatform plarform, optional optional CLenum deviceType =

WebCL.DEVICE_TYPE_DEFAULT) (OpenCL 1.1 §4.3, clCreateContextFromType)

주어진 플랫폼에서 사용이 가능하다면, 주어진 단말기 유형에 대해서 WebCL 켄텍스트는 WebCL을 새로 생성하여 돌려준다. deviceType에 대해 사용가능한 값은 아래 표에 보였다.

deviceType 설명

DEVICE_TYPE_CPU 싱글코어 또는 멀티코어 CPU, 일반적으로 호스트 프로세스



DEVICE_TYPE_DEFAULT 주어진 플랫폼에 있는 디폴트 단말기


TTAK.OT-10.0390 １２

DEVICE_TYPE_ALL 주어진 플랫폼에 있는 모든 단말기

Exceptions:

INVALID_OPERATION – 이 기능이 WebCLCallback에서 요청될 경우 INVALID_PLATFORM – 플랫폼이 WebCLPlatform 객체가 아닐 경우 INVALID_DEVICE_TYPE – deviceType에 DEVICE_TYPE 사용할 수 없을 경우 DEVICE_NOT_FOUND – deviceType이 발견된 플랫폼에서 일치하는 단말기가 없을 경우 DEVICE_NOT_AVAILABLE – 플랫폼에서 사용가능한 deviceType과 일치하는 단말기가 없을

경우

WebCLContext createContext(WebCLDevice device) (OpenCL 1.1 §4.3, clCreateContext)

주어진 단말기에 대해서 새롭게 생성된 WebCL을 생성하여 반환한다.

Exceptions:

INVALID_OPERATION – 이 기능이 WebCLCallback으로 부터 요청될 경우

INVALID_DEVICE – 단말기가 유효한 WebCLDevice 객체가 아닐 경우

DEVICE_NOT_AVAILABLE – 주어진 단말기가 현재 사용이 불가능할 경우

WebCLContext createContext(sequence<WebCLDevice> devices); (OpenCL 1.1 §4.3,

clCreateContext)

주어진 단말기 목록에 있는 생성된 WebCL 컨텍스트(context)를 반환한다.

Exceptions:

INVALID_OPERATION – 이 기능이 WebCLCallback에 의해서 호출되었을 경우

INVALID_VALUE - devices.length === 0일 경우

INVALID_DEVICE – 단말기에 있는 특정 요소(element)가 WebCLDevice에서 유효하지

않을 경우

INVALID_DEVICE – 주어진 특정 단말기가 다른 플랫폼에 있을 경우

DEVICE_NOT_AVAILABLE – 주어진 특정 단말기가 사용이 불가능할 경우

sequence<DOMString>? getSupportedExtensions() (OpenCL 1.1 §9)

모든 WebCLPlatform이 WebCLDevices에 의해 지원되는 확장 배열 이름을 반환한다. 목록에

있는 enableExtension에 전달될 때 이 목록에 있는 특정 문자열이 해당되는 확장을 사용할 수

있도록 해야 한다.

CLboolean enableExtension(DOMString extensionName)

모든 WebCLPlatforms과 WebCLDevices의 주어진 확장을 사용할 수 있게 한다. 만약 확장이

성공적으로 사용 가능하게 되면 true를 반환하고, 아니면 false를 반환한다. 가능한 확장 이름은

getSupportedExtensions를 사용하여 요청할 수 있다. 사용 가능해진 확장 기능은 소급하여

적용되지 않는다는 것에 주의해야 한다. 다시 말해서, 확장이 가능해지기 전에 생성된

컨텍스트(context)는 계속 확장된 능력을 갖추지 못한다.

void waitForEvents(sequence<WebCLEvent> eventWaitList, optional WebCLCallback

whenFinished) (OpenCL 1.1 §5.9, clWaitForEvents)

evenWaitList에 있는 모든 이벤트가 완료되었을 때 주어진 콜백 요청한다. 만약 콜백이 제공되지

않으면, 자바스크립트 메인 스레드는 이벤트가 완료될 때까지 차단될 것이다. 애플리케이션은


TTAK.OT-10.0390 １３

콜백을 제공하는 것을 강력하게 요청하고 있으며, 차단 상태는 기존 OpenCL 코드의 포팅을

쉽게 한다.

Exceptions:

INVALID_OPERATION – 이 기능의 차단 폼(from)으로 WebCLCallback이 호출될 경우

INVALID_VALUE - eventWaitList가 0이거나 비었을 경우

INVALID_CONTEXT – eventWaitList에서 지정된 이벤트가 정해진 경우 동일한

컨텍스트(context)에 속하지 않았을 때

INVALID_EVENT_WAIT_LIST – eventWaitList에 있는 이벤트가 유효하지 않을 경우

INVALID_EVENT_WAIT_LIST – 콜백이 지원될 때, eventWaitList에 있는 특정 이벤트가

WebCLUserEvent이거나 새롭게 생성된(활성화되지 않은) WebCLEvent일 경우

INVALID_EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST – eventWaitList에 있는

특정 이벤트의 실행 상태가 음의 정수값일 경우

void releaseAll() (OpenCL 1.1 §4.3, clReleaseContext)

모든 WebCLContext 인스턴스(instance)와 그 상속된 객체들을 해제한다.

예제 2

// createContext의 유효한 예제. 모든 가능한 단말기가 사용가능하다고 // 가정하고, 모든 유효한 컨텍스트(context)를 생성한다. ctx = webcl.createContext(); ctx = webcl.createContext(WebCL.DEVICE_TYPE_CPU); ctx = webcl.createContext(aPlatform); ctx = webcl.createContext(aPlatform, WebCL.DEVICE_TYPE_GPU); ctx = webcl.createContext(aPlatform, WebCL.DEVICE_TYPE_ALL); ctx = webcl.createContext(aDevice); ctx = webcl.createContext([aDevice, anotherDeviceOnTheSamePlatform]); // createContext가 유효하지 않은 예제. 이 경우 예외(exception)를 전달한다. ctx = webcl.createContext(0x1234); ctx = webcl.createContext(WebCL.DEVICE_TYPE_ALL); ctx = webcl.createContext({}); ctx = webcl.createContext([]); ctx = webcl.createContext(aPlatform, 0x1234); ctx = webcl.createContext([aValidDevice, null]); ctx = webcl.createContext([aDeviceOnPlatformA, aDeviceOnPlatformB]);

6.2. WebCL 플랫폼

interface WebCLPlatform {

any getInfo(CLenum name);

sequence<WebCLDevice> getDevices(optional CLenum deviceType);



};


TTAK.OT-10.0390 １４

sequence<WebCLDevice> getDevices(optional CLenum deviceType) (OpenCL 1.1 §4.2,

clGetDeviceIDs)

WebCLPlatform에서 가능한 WebCLDevices를 가져오고, 주어진 유형과 일치시킴. 유효한 단말

기 유형은 아래 표에 나열하였다. 디바이스 유형이 없으면 DEVICE_TYPE_ALL이 된다.

deviceType 설명

DEVICE_TYPE_CPU 싱글코어 또는 멀티코어 CPU, 일반적으로 호스트 프로세스



DEVICE_TYPE_DEFAULT 플랫폼에 있는 디폴트(default) 디바이스

DEVICE_TYPE_ALL 플랫폼에 있는 모든 디바이스

예외:

INVALID_VALUE - deviceType 을 받았지만, 위 표에 없을 경우

DEVICE_NOT_FOUND – 받은 deviceTyp과 일치하는 WebCLDevice가 없을 경우

any getInfo(CLenum name) (OpenCL 1.1 §4.1, clGetPlatformInfo)

WebCLPlatform에 대해서 정보를 가져옴. 가능한 요청 인자는 아래 표에 목록화되어있다. 이

구현 방법에 따른다. 구현할 때에 개인정보 보호 정책에 따라서 반환 값의 일부는 비어 있거나

중요한 OpenCL 단말기를 잘 반영하지 못한다. 구현할때는 System Info 확장을 통하여 권한을

가진 애플리케이션 (브라우저 확장과 개발 도구들)만 사용할 수 있도록 중요한 값을 숨기는

것을 추천한다.

name 반환 형태 예상된 반환 값

PLATFORM_PROFILE DOMString “WEBCL_PROFILE”+ 선택적 공급자(vendor)

문자열

PLATFORM_VERSION DOMString “WebCL 1.0”+선택적 공급자(vendor) 문자열

PLATFORM_NAME DOMString 공급자(vendor) 지정

PLATFORM_VENDOR DOMString 공급자(vendor) 지정

PLATFORM_EXTENSIONS DOMString 공급자(vendor) 지정

예외:

INVALID_VALUE = name 유효한 열거값이 아닐 경우

sequence<DOMString>? getSupportedExtensions() (OpenCL 1.1 §9, clGetPlatformInfo)

WebCLPlatform에 있는 모든 WebCLDevices에 의해서 지원하는 확장 이름의 배열을 반환한다.

목록에 있는 enableExtension에 전달될 때 이 목록에 있는 특정 문자열이 대응하는 확장을

사용할 수 있도록 해야 한다.


WebCLPlatform에 있는 주어진 WebCL 확장을 가능하게 한다. 만약 성공적으로 사용가능하게


TTAK.OT-10.0390 １５

되면 true를 반환하고, 아니면 false를 반환한다. 가능한 확장 이름은

getSupportedExtensions에 의해서 요청할 수 있다. 사용 가능해진 확장 기능은 소급하여



6.3. WebCL 디바이스

interface WebCLDevice {




any getInfo(CLenum name) (OpenCL 1.1 §4.2, clGetDeviceInfo)

WebCLDevice에 대해서 정보를 가져옴. 가능한 요청 인자는 아래 표에 목록화되어있다. 이

구현 방법에 따른다. 구현을 할 때에 개인정보 보호 정책에 따라서 반환 값의 일부는 비어

있거나 중요한 OpenCL 단말기를 잘 반영하지 못한다. 구현할 때는 System Info 확장을 통하여

권한을 가진 애플리케이션 (브라우저 확장과 개발 도구들)만 사용할 수 있도록 중요한 값을

숨기는 것을 추천한다.

deviceType 반환 값 예상 반환 값

DEVICE_PROFILE DOMString “WEBCL_PROFILE” + 선택적 공급자 문자열

DEVICE_VERSION DOMString “WebCL 1.0” + 선택적 공급자 문자열

DEVICE_OPENCL_C_VERSION DOMString “WebCL C 1.0” + 선택적 공급자 문자열

DEVICE_NAME DOMString 공급자 지정

DEVICE_VENDOR DOMString 공급자 지정

DEVICE_VENDOR_ID CLuint 공급자 지정

DRIVER_VERSION DOMString 공급자 지정

DEVICE_EXTENSIONS DOMString 공급자 지정

DEVICE_AVAILABLE CLboolean true

DEVICE_COMPILER_AVAILABLE CLboolean true

DEVICE_TYPE CLenum { DEVICE_TYPE_CPU, DEVICE_TYPE_GPU,

DEVICE_TYPE_ACCELERATOR } 중 하나 또는

그 이상

DEVICE_MAX_COMPUTE_UNITS CLuint >= 1

DEVICE_MAX_WORK_ITEM_DIMENSI

ONS

CLuint >= 3

DEVICE_MAX_WORK_ITEM_SIZES CLuint >= (1, 1, 1)

DEVICE_MAX_WORK_GROUP_SIZE CLuint >= 1

DEVICE_PREFERRED_VECTOR_WID

TH_{CHAR, SHORT, INT, LONG,

FLOAT}

CLuint >= 1

DEVICE_NATIVE_VECTOR_WIDTH_{ CLuint >= 1


TTAK.OT-10.0390 １６

CHAR, SHORT, INT, LONG, FLOAT}

DEVICE_MAX_CLOCK_FREQUENCY CLuint >= 0

DEVICE_ADDRESS_BITS CLuint 32 또는 64

DEVICE_MAX_MEM_ALLOC_SIZE CLulong >= max(DEVICE_GLOBAL_MEM_SIZE/4,

1024*1024)

DEVICE_IMAGE_SUPPORT CLboolean >= max(DEVICE_GLOBAL_MEM_SIZE/4,

1024*1024)

DEVICE_MAX_READ_IMAGE_ARGS CLuint >= 8

DEVICE_MAX_WRITE_IMAGE_ARGS CLuint >= 1

DEVICE_IMAGE2D_MAX_WIDTH CLuint >= 2048

DEVICE_IMAGE2D_MAX_HEIGHT CLuint >= 2048


DEVICE_IMAGE3D_MAX_HEIGHT CLuint >= 0


DEVICE_MAX_SAMPLERS CLuint >= 8

DEVICE_MAX_PARAMETER_SIZE CLuint >= 256 bytes

DEVICE_MEM_BASE_ADDR_ALIGN CLuint >= numBits(float16) = 16*32 = 512

DEVICE_SINGLE_FP_CONFIG CLenum {FP_ROUND_TO_NEAREST,

FP_ROUND_TO_ZERO } 한 개 또는 이상의

조합. { FP_DENORM, FP_INF_NAN,

FP_ROUND_TO_INF, FP_FMA,

FP_SOFT_FLOAT} 0 또는 그 이상

DEVICE_GLOBAL_MEM_CACHE_TYP

E

CLenum { NONE, READ_ONLY_CACHE,

READ_WRITE_CACHE } 중 하나

DEVICE_GLOBAL_MEM_CACHELINE

_SIZE

CLuint >= 0 bytes

DEVICE_GLOBAL_MEM_CACHE_SIZ

E

CLulong >= 0 bytes

DEVICE_GLOBAL_MEM_SIZE CLulong >= 1024*1024 bytes

DEVICE_MAX_CONSTANT_BUFFER_

SIZE

CLulong >= 1024 bytes

DEVICE_MAX_CONSTANT_ARGS CLuint >= 4

DEVICE_LOCAL_MEM_TYPE CLenum { LOCAL, GLOBAL} 중 하나

DEVICE_LOCAL_MEM_SIZE CLulong >= 1024 butes

DEVICE_ERROR_CORRECTION_SUP

PORT

CLboolean true/false

DEVICE_HOST_UNIFIED_MEMORY CLboolean true/false

DEVICE_PROFILING_TIMER_RESOL

UTION

CLuint >=0

DEVICE_ENDIAN_LITTLE CLboolean true/false

DEVICE_EXECUTION_CAPABILITIES CLenum EXEC_KETNEL

DEVICE_QUEUE_PROPETIES CLenum { QUEUE_PROFILING_ENABLE,

QUEUE_OUT_OF_ORDER_EXEC_MODE_ENABL

E } 0이나 그 이상


TTAK.OT-10.0390 １７

DEVICE_PLATFORM WebCLPlatfor

m

Object

예외:

INVALID_VALUE – name이 유효한 열거값이 아닌 경우

sequence<DOMString>? getSupportedExtensions() (OpenCL 1.1 §9, clGetDeviceInfo)

WebCLDevice에 의해 지원되는 확장 이름의 배열을 반환한다. 목록에 있는 enableExtension에

전달될 때 이 목록에 있는 특정 문자열이 대응하는 확장을 사용할 수 있도록 해야 한다.


WebCLDevice에 있는 주어진 WebCL을 사용할 수 있도록 한다. 만약 확장이 성공하여 사용

가능하면 true를 반환하고, 아니면 false를 반환한다. 가능한 확장 이름은

getSupportedExtensions를 사용하여 요청할 수 있다. 사용 가능해진 확장 기능은 소급하여



6.4. WebCL 컨텍스트(context)

interface WebCLContext {

WebCLBuffer createBuffer(CLenum memFlags, CLuint sizeInBytes, optional ArrayBufferView

hostPtr);

WebCLCommandQueue createCommandQueue(optional WebCLDevice? device, optional

CLenum properties);

WebCLImage createImage(CLenum memFlags,

WebCLImageDescriptor descriptor,

optional ArrayBufferView hostPtr);

WebCLProgram createProgram(DOMString source);

WebCLSampler createSampler(CLboolean normalizedCoords,

CLenum addressingMode,

CLenum filterMode);

WebCLUserEvent createUserEvent();


sequence<WebCLImageDescriptor>? getSupportedImageFormats(optional CLenum

memFlags = MEM_READ_WRITE);

void release();

void releaseAll();

};


TTAK.OT-10.0390 １８

WebCLBuffer createBuffer(CLenum memFlags, CLuint sizeInBytes, optional ArrayBufferView

hostPtr) (OpenCL 1.1 §5.2.1, clCreateBuffer)

sizeinBytes의 용량과 함께 새로운 WebCLBuffer 생성하고, 주어진 ArrayBufferView로부터

얻어진 데이터를 선택적으로 채운다.

예외:

INVALID_VALUE – memFlags이 MEM_READ_WRITE, MEM_WRITE_ONLY 아니거나

MEM_READ_ONLY 일 경우

INVALID_BUFFER_SIZE - sizeInBytes == 0 || sizeInBytes >

DEVICE_MAX_MEM_ALLOC_SIZE일 경우

INVALID_HOST_PTR - hostPtr.byteLength < sizeInBytes 일 경우

WebCLCommandQueue createCommandQueue(optional WebCLDevice? device = null, optional

CLenum properties = 0) (OpenCL 1.1 §5.1, clCreateCommandQueue)

주어진 단말기에 대해서 새로운 명령 큐(queue) 생성. 만약 단말기가 널(null)이면, WebCL

구현은 주어진 특성과 일치하고, WebCLContext에 포함된 특정 WebCLDevice 단말기를

선택한다. 만약 특성이 빠지면, 명령 큐(queue)는 실행이 중지(out-of-order execution)되고,

프로파일링(profiling)을 사용할 수 없게 된다.

예외:

INVALID_OPERATION – 기능이 WebCLCallback로부터 호출될 경우

INVALID_DEVICE - 단말기가 유효하기 않거나 이 컨텍스트(context)와 관련이 없을 경우

INVALID_VALUE - 특성값이 지정되지 않았거나 유효하지 않을 경우

INVALID_QUEUE_PROPERTIES -- 특성값이 유효하지만, 해당 단말기에서 지원되지 않을

경우

WebCLImage createImage(CLenum memFlags, WebCLImageDescriptor descriptor, optional

ArrayBufferView hostPtr = null) (OpenCL 1.1 §5.3.1, clCreateImage2D)

선택적으로 주어진 ArrayBufferView로부터 데이터가 채워지거나, 기술자 (descriptor)에 지정된

높이와 폭이 있는 새로운 WebCLImage를 생성한다.

예외:

INVALID_VALUE - memFlags이 MEM_READ_WRITE, MEM_WRITE_ONLY 아니거나

MEM_READ_ONLY 일 경우

INVALID_IMAGE_SIZE - descriptor.width == 0 || descriptor.width >

DEVICE_IMAGE2D_MAX_WIDTH 일 경우

INVALID_IMAGE_SIZE - descriptor.height == 0 || descriptor.height >

DEVICE_IMAGE2D_MAX_HEIGHT 일 경우

INVALID_IMAGE_SIZE - hostPtr === null && descriptor.rowPitch !== 0 일 경우

INVALID_IMAGE_SIZE - hostPtr !== null && descriptor.rowPitch > 0 &&

descriptor.rowPitch < descriptor.width * bytesPerPixel 일 경우

INVALID_HOST_PTR - hostPtr.byteLength < descriptor.rowPitch * descriptor.height 일

경우

INVALID_IMAGE_FORMAT_DESCRIPTOR - descriptor.channelOrder 이거나


TTAK.OT-10.0390 １９

descriptor.channelType 이 유효하지 않은 경우

IMAGE_FORMAT_NOT_SUPPORTED - 주어진 channelOrder, channelType 조합과

memFlags이 WebCLContext에 의해 지원되지 않을 경우

WebCLProgram createProgram(DOMString source) (OpenCL 1.1 §5.6.1,

clCreateProgramWithSource)

UTF-8로부터 WebCLProgram 생성한다.

예외:

INVALID_VALUE – 소스가 널(null)이거나 비어있을 경우

WebCLSampler createSampler(CLboolean normalizedCoords, CLenum addressingMode, CLenum

filterMode) (OpenCL 1.1 §5.5.1, clCreateSampler)

주어진 좌표 상태, 어드레싱(addressing) 상태, 필터링(filtering) 상태와 함께 새로운

WebCLSampler를 생성한다. ADDRESS_NONE 상태는 바운드(bound) 확인이 어려워 사용이

불가능하다.

예외:

INVALID_VALUE – addressingMode가 ADDRESS_CLAMP, ADDRESS_CLAMP_TO_EDGE,

ADDRESS_REPEAT 아니거나 ADDRESS_MIRRORED_REPEAT일 경우

INVALID_VALUE – filterMode가 FILTER_NEAREST 또는 FILTER_LINEAR가 아닐 경우

INVALID_VALUE – normalizedCoords가 false이고, addressingMode가

ADDRESS_REPEAT 또는 ADDRESS_MIRRORED_REPEAT 일 경우

WebCLUserEvent createUserEvent() (OpenCL 1.1 §5.9, clCreateUserEvent)

any getInfo(CLenum name) (OpenCL 1.1 §4.3, clGetContextInfo)

전달한 name의 값을 반환한다. 아래 표에 있는 요청한 name에 대한 자연스러운 형태가

반환된다.

name 반환 형태 설명

CONTEXT_NUM_DEVICES CLuint 이 컨텍스트(context)에 있는

단말기의 수

CONTEXT_DEVICES Sequecce<WebCLDevice> 이 컨텍스트(context)에 있는

단말기

예외:

INVALID_VALUE - name이 위 표에 있는 유효한 열거값 중의 하나가 아닐 경우

sequence<WebCLImageDescriptor>? getSupportedImageFormats(CLenum memFlags) (OpenCL

1.1 §5.3.2, clGetSupportedImageFormats)

주어진 memFlags과 함께 WebCLCentext에 의해 지원되는 이미지 포맷의 목록을 반환한다.

예를 들어서, MEM-READ_WRITE 넘겨주면, 커널(kernel) 코드를 읽고 쓸 때 모두 사용 가능한

이미지 포맷을 목록을 반환할 것이다.

반환된 WebCLImageDecriptor 객체는 채워진 channelOrder와 channelType 필드(field)를


TTAK.OT-10.0390 ２０

가지며, 다른 필드(field)는 자신의 기본값(0)을 가진다. 모든 단말기에 의해서 지원(읽기와

쓰기가 모두)되는 이미지 포맷의 최소 셋(set)이 아래 표에 정의되어 있다. 요구된 포맷의

셋(set)은 OpenCL 1.1 Embedded Profile과 동일하다.

channelOrder channelType

RGBA

UNORM_INT8

UNORM_INT16

SIGNED_INT8

SIGNED_INT16

SIGNED_INT32

UNSIGNED_INT8

UNSIGNED_INT16

UNSIGNED_INT32

HALF_FLOAT

FLOAT

예외:

INVALID_VALUE – memFlags이 MEM_READ_WRITE, MEM_WRITE_ONLY 아니거나

MEM_READ_ONLY일 경우

void release() (OpenCL 1.1 §4.3, clReleaseContext)

객체에 의해서 사용된 리소스를 해제한다.

void releaseAll() (OpenCL 1.1 §4.3, clReleaseContext)Releases the resources held up by this

WebCLContext와 그로 인해 생성된 모든 객체에서 지정된 리소스를 모두 해제한다.

6.4.1. WebCLImageDescriptor

dictionary WebCLImageDescriptor {

CLenum channelOrder = 0x10B5; // 0x10B5 == WebCL.RGBA

CLenum channelType = 0x10D2; // 0x10D2 == WebCL.UNORM_INT*, 8-bit

colors normalized to [0, 1]

CLuint width = 0, height = 0; CLuint rowPitch = 0;

};

6.5. WebCLCommondQueue

interface WebCLCommandQueue {

//////////////////////////////////////////////////////////////////////////// // // Copying: Buffer <-> Buffer, Image <-> Image, Buffer <-> Image // void enqueueCopyBuffer( WebCLBuffer srcBuffer, WebCLBuffer dstBuffer, CLuint srcOffset, CLuint dstOffset,


TTAK.OT-10.0390 ２１

CLuint numBytes, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueCopyBufferRect( WebCLBuffer srcBuffer, WebCLBuffer dstBuffer, sequence<CLuint> srcOrigin, sequence<CLuint> dstOrigin, sequence<CLuint> region, CLuint srcRowPitch, CLuint srcSlicePitch, CLuint dstRowPitch, CLuint dstSlicePitch, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueCopyImage( WebCLImage srcImage, WebCLImage dstImage, sequence<CLuint> srcOrigin, sequence<CLuint> dstOrigin, sequence<CLuint> region, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueCopyImageToBuffer( WebCLImage srcImage, WebCLBuffer dstBuffer, sequence<CLuint> srcOrigin, sequence<CLuint> srcRegion, CLuint dstOffset, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueCopyBufferToImage( WebCLBuffer srcBuffer, WebCLImage dstImage, CLuint srcOffset, sequence<CLuint> dstOrigin, sequence<CLuint> dstRegion, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); //////////////////////////////////////////////////////////////////////////// // // Reading: Buffer -> Host, Image -> Host // void enqueueReadBuffer( WebCLBuffer buffer, CLboolean blockingRead, CLuint bufferOffset, CLuint numBytes, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueReadBufferRect( WebCLBuffer buffer, CLboolean blockingRead,


TTAK.OT-10.0390 ２２

sequence<CLuint> bufferOrigin, sequence<CLuint> hostOrigin, sequence<CLuint> region, CLuint bufferRowPitch, CLuint bufferSlicePitch, CLuint hostRowPitch, CLuint hostSlicePitch, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueReadImage( WebCLImage image, CLboolean blockingRead, sequence<CLuint> origin, sequence<CLuint> region, CLuint hostRowPitch, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); //////////////////////////////////////////////////////////////////////////// // // Writing: Host -> Buffer, Host -> Image // void enqueueWriteBuffer( WebCLBuffer buffer, CLboolean blockingWrite, CLuint bufferOffset, CLuint numBytes, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueWriteBufferRect( WebCLBuffer buffer, CLboolean blockingWrite, sequence<CLuint> bufferOrigin, sequence<CLuint> hostOrigin, sequence<CLuint> region, CLuint bufferRowPitch, CLuint bufferSlicePitch, CLuint hostRowPitch, CLuint hostSlicePitch, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); void enqueueWriteImage( WebCLImage image, CLboolean blockingWrite, sequence<CLuint> origin, sequence<CLuint> region, CLuint hostRowPitch, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); //////////////////////////////////////////////////////////////////////////// //


TTAK.OT-10.0390 ２３

// Executing kernels // void enqueueNDRangeKernel( WebCLKernel kernel, CLuint workDim, sequence<CLuint>? globalWorkOffset, sequence<CLuint> globalWorkSize, optional sequence<CLuint>? localWorkSize, optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event); //////////////////////////////////////////////////////////////////////////// // // Synchronization // void enqueueMarker(WebCLEvent event); void enqueueBarrier(); void enqueueWaitForEvents (sequence<WebCLEvent> eventWaitList); void finish(optional WebCLCallback whenFinished); void flush(); //////////////////////////////////////////////////////////////////////////// // // Querying command queue information // any getInfo(CLenum name); void release(); };

void enqueueCopyBuffer( WebCLBuffer srcBuffer, WebCLBuffer dstBuffer, CLuint srcOffset,

CLuint dstOffset, CLuint numBytes, optional sequence<WebCLEvent>? eventWaitList, optional

WebCLEvent? event) (OpenCL 1.1 §5.2.2, clEnqueueCopyBuffer)

예외:

INVALID_CONTEXT - WebCLCommandQueue가 srcBuffer와 dstBuffer로 같은

WebCLContext와 연결되어 있지 않을 경우

INVALID_CONTEXT - WebCLCommandQueue가 eventWaitList에 있는 모든 이벤트로

같은 WebCLContext와 연결되어 있지 않을 경우

INVALID_MEM_OBJECT - srcBuffer와 dstBuffer가 유효한 WebCLBuffer 객체가 아닐

경우

INVALID_VALUE - srcOffset, dstOffset, numBytes, srcOffset+numBytes, 또는

dstOffset+numBytes가 srcBuffer와 dstBuffer 버퍼(buffer) 객체의 외부 요소(element)에

접근을 각각 요구할 경우

INVALID_EVENT_WAIT_LIST - eventWaitList에 있는 어떤 이벤트가 유효하지 않을 때

INVALID_EVENT - event가 새로 생성된 빈 WebCLEvent가 아닐 경우

http://www.khronos.org/registry/cl/specs/opencl-1.1.pdf#nameddest=section-5.2.2

http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueCopyBuffer.html


TTAK.OT-10.0390 ２４

MEM_COPY_OVERLAP - srcBuffer와 dstBuffer가 동일한 WebCLBuffer 객체이며, 소스와

목적지가 동일한 영역에 중복될 때

MISALIGNED_SUB_BUFFER_OFFSET – srcBuffer 또는 dstBuffer가 서브 버퍼(sub-

buffer) 객체이며, 생성된 서브 버퍼(sub-buffer) 객체가 단말기와 그와 연결된

WebCLCommandQueue에 대해서 DEVICE_MEM_BASE_ADDR_ALIGN 값이 정렬되지

않았을 때 오프셋(offset)이 지정될 경우

MEM_OBJECT_ALLOCATION_FAILURE – srcBuffer 또는 dstBuffer에 연결된 데이터

저장소에 대해서 메모리 할당이 실패할 경우

void enqueueCopyBufferRect( WebCLBuffer srcBuffer, WebCLBuffer dstBuffer, sequence<CLuint>

srcOrigin, sequence<CLuint> dstOrigin, sequence<CLuint> region, CLuint srcRowPitch, CLuint

srcSlicePitch, CLuint dstRowPitch, CLuint dstSlicePitch, optional sequence<WebCLEvent>?

eventWaitList, optional WebCLEvent? event); (OpenCL 1.1 §5.2.2, clEnqueueCopyBufferRect)

Exceptions:

INVALID_CONTEXT - WebCLCommandQueue가 srcBuffer와 dstBuffer로 같은




INVALID_MEM_OBJECT - srcBuffer와 dstBuffer가 유효한 WebCLBuffer 객체가 아닐

경우

INVALID_VALUE - srcOrigin, dstOrigin 또는 region이 정확하게 다른 요소(element)가

아닐 경우

INVALID_VALUE - origin, region과 pitch 값이 srcBuffer와 dstBuffer 버퍼(buffer) 객체의

외부 요소(element)에 접근을 각각 요구할 경우

INVALID_EVENT_WAIT_LIST - eventWaitList가 어떤 이벤트가 유효하지 않을 때


MEM_COPY_OVERLAP - srcBuffer와 dstBuffer가 동일한 WebCLBuffer 객체이며, 소스와

목적지가 동일한 영역에 중복될 때

MISALIGNED_SUB_BUFFER_OFFSET - srcBuffer 또는 dstBuffer가 서브 버퍼(sub-

buffer) 객체이며, 생성된 서브 버퍼(sub-buffer) 객체가 단말기와 그와 연결된

WebCLCommandQueue에 대해서 DEVICE_MEM_BASE_ADDR_ALIGN 값이 정렬되지

않았을 때 오프셋(offset)이 지정될 경우

void enqueueCopyImage( WebCLImage srcImage, WebCLImage dstImage, sequence<CLuint>

srcOrigin, sequence<CLuint> dstOrigin, sequence<CLuint> region, optional

sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event) (OpenCL 1.1 §5.2.2,

clEnqueueCopyImage)

Exceptions:

INVALID_CONTEXT - WebCLCommandQueue가 srcImage와 dstImage로 같은




http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueCopyBufferRect.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueCopyImage.html


TTAK.OT-10.0390 ２５


INVALID_MEM_OBJECT - srcImage와 dstImager가 유효한 WebCLBuffer 객체가 아닐

경우

IMAGE_FORMAT_MISMATCH – srcImage와 dstImage가 같은 이미지 포맷(format)이 아닐

경우

INVALID_VALUE - srcOrigin, dstOrigin과 region 값이 srcImage 또는 dstImage의

경계밖의 요소(elements)의 접근을 요구할 경우

INVALID_VALUE - srcOrigin, dstOrigin 또는 region이 정확하게 다른 요소(element)가

아닐 경우



INVALID_IMAGE_SIZE – srcImage 또는 dstImage 이미지 크기가

WebCLCommandQueue와 연결된 단말기에 의해서 지원되지 않을 경우

MEM_OBJECT_ALLOCATION_FAILURE – srcImage 또는 dstImagae에 연결된 데이터

저장소의 메모리를 할당하는데 실패할 경우

MEM_COPY_OVERLAP - srcImager와 dstBuffer가 동일한 WebCLBuffer 객체이며,

소스와 목적지가 동일한 영역에 중복될 때

void enqueueCopyBufferToImage( WebCLBuffer srcBuffer, WebCLImage dstImage, CLuint

srcOffset, sequence<CLuint> dstOrigin, sequence<CLuint> dstRegion, optional


clEnqueueCopyBufferToImage)

Exceptions:

INVALID_CONTEXT - WebCLCommandQueue가 srcBuffer와 dstImage로 같은




INVALID_MEM_OBJECT - srcbuffer가 유효한 버퍼(buffer) 객체가 아니거나 dstImage가

유효한 이미지 객체가 아닐 경우

INVALID_VALUE - srcOrigin 또는 dstOrigin이 정확하게 다른 요소(element)가 아닐 경우

INVALID_VALUE - srcOffset, dstOrigin과 dstRegion 값이 srcBuffer 또는 dstImage의




INVALID_IMAGE_SIZE - dstImage 이미지 크기가 WebCLCommandQueue와 연결된

단말기에 의해서 지원되지 않을 경우

MEM_OBJECT_ALLOCATION_FAILURE - srcBuffer 또는 dstImagae에 연결된 데이터


void enqueueCopyImageToBuffer( WebCLImage srcImage, WebCLBuffer dstBuffer,

sequence<CLuint> srcOrigin, sequence<CLuint> srcRegion, CLuint dstOffset, optional


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueCopyBufferToImage.html


TTAK.OT-10.0390 ２６


clEnqueueCopyImageToBuffer)

Exceptions:

INVALID_CONTEXT - WebCLCommandQueue가 srcImage와 dstBuffer로 같은




INVALID_MEM_OBJECT - srcImager가 유효한 버퍼(buffer) 객체가 아니거나 dstBuffer가

유효한 이미지 객체가 아닐 경우

INVALID_VALUE – srcOrigin 또는 srcRegion이 정확하게 다른 요소(element)가 아닐 경우

INVALID_VALUE - srcOrigin, srcRegion과 dstOrigin 값이 srcImage 또는 dstImage의




INVALID_IMAGE_SIZE - srctImage 이미지 크기가 WebCLCommandQueue와 연결된


MEM_OBJECT_ALLOCATION_FAILURE - srcImage 또는 dstBuffer에 연결된 데이터


void enqueueReadBuffer( WebCLBuffer buffer, CLboolean blockingRead, CLuint bufferOffset,

CLuint numBytes, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList,

optional WebCLEvent? event) (OpenCL 1.1 §5.2.2, clEnqueueReadBuffer)

Exceptions:

INVALID_OPERATION – 이 기능의 차단 폼(form) WebCLCallback에 의해서 호출되었을

경우

INVALID_CONTEXT - WebCLCommandQueue가 buffer로 같은 WebCLContext와

연결되어 있지 않을 경우



INVALID_MEM_OBJECT – buffer가 유효한 객체가 아닐 경우

INVALID_VALUE - bufferOffset 과 numBytes에 의해서 읽기용으로 지정된 일부분이

buffer의 범위 밖일 경우

INVALID_VALUE – hostPtr과 numButes에 의해 쓰기 영역으로 지정된 일부분이 hostPtr의

범위 밖일 경우

INVALID_VALUE - numBytes % hostPtr.BYTES_PER_ELEMENT !== 0일 경우


INVALID_EVENT_WAIT_LIST - blockingRead가 true이고, eventWaitList에 있는 모든

이벤트가 WebCLUserEvent 또는 새롭게 생성된 (비활성의) WebCLEvent일 경우

EXEC_STATUS_ERROR_FOR_EVENTS_IN_WAIT_LIST - blockingRead가 true이고,

eventWaitList에 있는 모든 이벤트의 실행 상태가 음의 정수를 가질 경우

INVALID_EVENT – event가 새로 생성된 WebCLEvent이 아닐 경우


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueCopyImageToBuffer.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueReadBuffer.html


TTAK.OT-10.0390 ２７

void enqueueReadBufferRect( WebCLBuffer buffer, CLboolean blockingRead, sequence<CLuint>

bufferOrigin, sequence<CLuint> hostOrigin, sequence<CLuint> region, CLuint bufferRowPitch,

CLuint bufferSlicePitch, CLuint hostRowPitch, CLuint hostSlicePitch, ArrayBufferView hostPtr,

optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event) (OpenCL 1.1

§5.2.2, clEnqueueReadBufferRect)

Exceptions:

`INVALID_OPERATION - 이 기능의 차단 폼(form) WebCLCallback에 의해서 호출되었을

경우





INVALID_MEM_OBJECT - buffer가 유효한 WebCLBuffer 객체가 아닐 경우

INVALID_VALUE - bufferOrigin, hostOrigin 또는 region이 정확하게 다른 세가지

요소(element)가 아닐 경우

INVALID_VALUE - bufferOrigin과 region, bufferRowPitch와 bufferSlicePitch에 의해 읽기

영역으로 지정된 일부분이 buffer의 범위 밖일 경우

INVALID_VALUE – hostOrigin, region, hostRowPitch와 hostSlicePitch에 의해 읽기

영역으로 지정된 일부분이 hostPtr의 범위 밖일 경우

INVALID_VALUE - host{Row,Slice}Pitch % hostPtr.BYTES_PER_ELEMENT !== 0 일 경우


INVALID_EVENT_WAIT_LIST – blockingRead가 true이고, eventWaitList에 있는 모든

이벤트가 WebCLUserEvent 또는 새로 생성된 (비활성의) WebCLEvent일 경우



INVALID_EVENT – event가 새로 생성된 빈 WebCLEvent가 아닐 경우

void enqueueReadImage( WebCLImage image, CLboolean blockingRead, sequence<CLuint>

origin, sequence<CLuint> region, CLuint hostRowPitch, ArrayBufferView hostPtr, optional


clEnqueueReadImage)

Exceptions:

INVALID_OPERATION - 이 기능의 차단 폼(form) WebCLCallback에 의해서 호출되었을

경우

INVALID_CONTEXT - WebCLCommandQueue가 image로 같은 WebCLContext와




INVALID_MEM_OBJECT - image가 유효한 WebCLBuffer 객체가 아닐 경우

INVALID_IMAGE_SIZE - Image 이미지 크기가 WebCLCommandQueue와 연결된



http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueReadBufferRect.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueReadImage.html


TTAK.OT-10.0390 ２８


INVALID_VALUE - origin 또는 region이 정확하게 다른 요소(element)가 아닐 경우

INVALID_VALUE - origin 과 region에 의해서 읽기 영역으로 지정된 부분이 image의 범위

밖일 경우

INVALID_VALUE - region과 hostRowPitch에 의해 쓰기 영역으로 지정된 일부분이

hostPtr의 범위 밖일 경우

INVALID_VALUE - hostRowPitch % hostPtr.BYTES_PER_ELEMENT !== 0 일 경우







void enqueueWriteBuffer( WebCLBuffer buffer, CLboolean blockingWrite, CLuint bufferOffset,

CLuint numBytes, ArrayBufferView hostPtr, optional sequence<WebCLEvent>? eventWaitList,

optional WebCLEvent? event) (OpenCL 1.1 §5.2.2, clEnqueueWriteBuffer)

Exceptions:

INVALID_OPERATION – 해당 기능의 차단 폼(form)이 WebCLCallback으로 부터 호출될

경우






`INVALID_VALUE` -- bufferOffset 과 numBytes에 의해서 쓰기 영역으로 지정된 부분이

buffer의 범위 밖일 경우

INVALID_VALUE - hostPtr과 numButes에 의해 읽기 영역으로 지정된 일부분이 hostPtr의

범위 밖일 경우

INVALID_VALUE - if numBytes % hostPtr.BYTES_PER_ELEMENT !== 0일 경우







void enqueueWriteBufferRect( WebCLBuffer buffer, CLboolean blockingWrite, sequence<CLuint>

bufferOrigin, sequence<CLuint> hostOrigin, sequence<CLuint> region, CLuint bufferRowPitch,

CLuint bufferSlicePitch, CLuint hostRowPitch, CLuint hostSlicePitch, ArrayBufferView hostPtr,

optional sequence<WebCLEvent>? eventWaitList, optional WebCLEvent? event) (OpenCL 1.1


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueWriteBuffer.html



TTAK.OT-10.0390 ２９

§5.2.2, clEnqueueWriteBufferRect)

Exceptions:

INVALID_OPERATION - 해당 기능의 차단 폼(form)이 WebCLCallback으로 부터 호출될

경우






INVALID_VALUE – bufferOrigin, hostOrigin 또는 region이 정확하게 다른 세가지

요소(element)가 아닐 경우

INVALID_VALUE – bufferOrigin, region, bufferRowPitch와 bufferSlicePitch에 의해 쓰기

영역으로 지정된 일부분이 buffer의 범위 밖일 경우

INVALID_VALUE - hostOrigin, region, hostRowPitch와 hostSlicePitch에 의해 읽기

영역으로 지정된 일부분이 hostPtr의 범위 밖일 경우

INVALID_VALUE - host{Row,Slice}Pitch % hostPtr.BYTES_PER_ELEMENT !== 0일 경우







void enqueueWriteImage( WebCLImage image, CLboolean blockingWrite, sequence<CLuint>

origin, sequence<CLuint> region, CLuint hostRowPitch, ArrayBufferView hostPtr, optional


clEnqueueWriteImage)

Exceptions:


경우

INVALID_CONTEXT - WebCLCommandQueue가 image로 같은 WebCLContext와




INVALID_MEM_OBJECT - imager가 유효한 WebCLBuffer 객체가 아닐 경우

INVALID_IMAGE_SIZE - 이미지 크기가 WebCLCommandQuere에 의해서 지원되지 않을

경우

INVALID_VALUE - origin 또는 region이 정확하게 다른 요소(element)가 아닐 경우

INVALID_VALUE - origin 과 region에 의해서 쓰기영역으로 지정된 부분이 image의 범위

밖일 경우

INVALID_VALUE – region과 hostRowPitch에 의해 읽기 영역으로 지정된 일부분이


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueWriteBufferRect.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueWriteImage.html


TTAK.OT-10.0390 ３０

hostPtr의 범위 밖일 경우

INVALID_VALUE - hostRowPitch % hostPtr.BYTES_PER_ELEMENT !== 0일 경우







void enqueueNDRangeKernel( WebCLKernel kernel, CLuint workDim, sequence<CLuint>?

globalWorkOffset, sequence<CLuint> globalWorkSize, optional sequence<CLuint>? localWorkSize

= null, optional sequence<WebCLEvent>? eventWaitList = null, optional WebCLEvent? event =

null) (OpenCL 1.1 §5.8, clEnqueueNDRangeKernel)

Exceptions:

INVALID_CONTEXT - WebCLCommandQueue가 kernel로 같은 WebCLContext와




INVALID_KERNEL - kernel이 유효한 WebCLKernel 객체가 아닐 경우

INVALID_PROGRAM_EXECUTABLE – WebCLCommandQueue와 연결된 단말에 대해서

사용할 수 있는 kernel 실행 프로그램이 성공적으로 빌드되었을 경우

INVALID_KERNEL_ARGS – kernel에 대해서 어떤 커널(kernel) 인수(argument) 값도

지정되지 않았을 경우

INVALID_WORK_DIMENSION - workDim이 1, 2, 또는 3이 아닐 경우

INVALID_GLOBAL_WORK_SIZE - globalWorkSize.length != workDim일 경우

INVALID_GLOBAL_WORK_SIZE - if globalWorkSize[i] > 232

-1 for any `i`일 경우

INVALID_GLOBAL_OFFSET - globalWorkOffset != null && (globalWorkOffset.length !=

workDim)일 경우

INVALID_GLOBAL_OFFSET – i에 대해서 globalWorkOffset != null && (globalWorkSize[i]

+ globalWorkOffset[i] > 232

-1)일 경우

INVALID_WORK_GROUP_SIZE - localWorkSize != null && (localWorkSize.length !=

workDim)일 경우

INVALID_WORK_GROUP_SIZE – i에 대해서 localWorkSize != null &&

(globalWorkSize[i] % localWorkSize[i] !== 0)일 경우

INVALID_WORK_GROUP_SIZE – 커널(kernel) 소스에 있는 인증자인

read_qork_work_group_size 를 사용하여 지정된 requiredSize가 있는 i에 대해서

localWorkSize != null && (localWorkSize[i] !== requiredSize[i])일 경우

INVALID_WORK_GROUP_SIZE - localWorkSize != null이고, work-group에 있는 work-

items의 전체 숫자가 (localWorkSize의 모든 요소의 결과) 해당 큐(queue)와 연결된

단말기로부터 요청된 DEVICE_MAX_WORK_GROUP_SIZE의 값보다 클 경우

INVALID_WORK_GROUP_SIZE – localWorkSize == null 이고, 명시자(qualifier)

http://www.khronos.org/registry/cl/specs/opencl-1.1.pdf#nameddest=section-5.8

http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueNDRangeKernel.html


TTAK.OT-10.0390 ３１

reqd_work_group_size가 커널(kernel) 소스에 있을 경우

INVALID_WORK_ITEM_SIZE – i에 대하여 localWorkSize != null && (localWorkSize[i] >

DEVICE_MAX_WORK_ITEM_SIZES[i]) 일 경우

INVALID_IMAGE_SIZE – 이미지 객체가 kernel에 대해서 인수로 지정되어 있고, 이미지

크기 (폭, 높이, 피치)가 단말기에 연결된 큐(queue_에 의해서 지원되지 않을 경우

MEM_OBJECT_ALLOCATION_FAILURE –kernel 인수로 지정된 이미지 또는 버퍼 객체에

와 연결된 데이터 저장소에 메모리 할당이 실패할 경우

INVALID_EVENT_WAIT_LIST - if any event in eventWaitList에 있는 이벤트가 유효하지

않을 경우


void enqueueMarker(WebCLEvent event) (OpenCL 1.1 §5.10, clEnqueueMarker)

Exceptions:

INVALID_VALUE - event가 유효한 WebCLEvent 객체가 아닐 경우

void enqueueBarrier() (OpenCL 1.1 §5.10, clEnqueueBarrier)

void enqueueWaitForEvents (sequence<WebCLEvent> eventWaitList); (OpenCL 1.1 §5.10,

clEnqueueWaitForEvents)

Exceptions:



INVALID_EVENT_WAIT_LIST – eventWaitList가 비었거나 유효하지 않은 이벤트를 포함한

경우

void finish(optional WebCLCallback whenFinished) (OpenCL 1.1 §5.13, clFinish)

이 큐(queue)에 있는 모든 명령어가 완료되었을 때 주어진 콜백(callback)을 호출한다. 만약

콜백(callback)이 제공되지 않으면, 자바스크립트 메인 스레드는 명령어가 완료될 때까지

차단될 것이다. 애플리케이션은 강력하게 콜백(callback)을 제공하도록 권고된다. 차단

모드는 주로 기존의 OpenCL 코드를 포팅(porting)하는 것을 쉽게 사용하기 위해 남아 있다.

예외:


경우

void flush() (OpenCL 1.1 §5.13, clFlush)

any getInfo(CLenum name) (OpenCL 1.1 §5.1, clGetCommandQueueInfo)

이름 반환 형태

QUEUE_CONTEXT WebCLContext

QUEUE_DEVICE WebCLDevice


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueMarker.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueBarrier.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clEnqueueWaitForEvents.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clFinish.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clFlush.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetCommandQueueInfo.html


TTAK.OT-10.0390 ３２

QUEUE_PROPERTIES CLenum

예외:

INVALID_VALUE – name이 위 표에 있는 유효한 열거형 값들 중의 하나가 아닌 경우 void release() (OpenCL 1.1 §5.1, clReleaseCommandQueue)

이 객체에 의해서 사용된 리소스를 해제한다.

예제 3

// 이 예제는 세 번째 커널(kernel)이 실행되기 전에 두 커널이 완료되기를 어떻게 기다리는지를

// 보여준다.

var eventWaitList = [ new WebCLEvent(), new WebCLEvent() ];

queue.enqueueNDRangeKernel(kernel1, dim, null, globals, null, null, eventWaitList[0]);

queue.enqueueNDRangeKernel(kernel2, dim, null, globals, null, null, eventWaitList[1]);

queue.enqueueNDRangeKernel(kernel3, dim, null, globals, null, eventWaitList);

예제 4

// 이 예제는 호스트(host) 메모리에 새로 생성된 Uint8Array로 WebCL 버퍼 객체의 모든

// 콘텐츠를 읽어 들인다.

function readBufferToHost(srcBuffer) {

// Query the number of bytes in the source buffer, create a new

// Uint8Array of that size, then fill it with a blocking read.

var numBytes = srcBuffer.getInfo(WebCL.MEM_SIZE);

var dstArray = new Uint8Array(numBytes);

queue.enqueueReadBuffer(srcBuffer, true, 0, numBytes, dstArray);

return dstArray;

};

예제 5

// 이 예제는 WebCL 버퍼로부터 WebCL 이미지 픽셀을 채운다.

function copyBufferToImage(srcBuffer, dstImage) {

// Extract the dimensions of the image.

var imgWidth = dstImage.getInfo(WebCL.IMAGE_WIDTH);

var imgHeight = dstImage.getInfo(WebCL.IMAGE_HEIGHT);

queue.enqueueCopyBufferToImage(srcBuffer, dstImage, 0, [0,0], [imgWidth, imgHeight]);

};

예제 6

// 이 예제는 버퍼 객체에서 다른 곳으로 메모리의 사각영역을 복사한다.

// 버퍼 객체는 동일한 크기로 가정한다. 오리진(origin), 폭, 높이와 피치(pitch)는 바이트로

http://www.khronos.org/registry/cl/specs/opencl-1.1.pdf#page=53

http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clReleaseCommandQueue.html


TTAK.OT-10.0390 ３３

// 주어진다. (픽셀(pixel)이 아닌 이유는 이것들의 이미지가 아니고 버퍼이기 때문임)

function copyBufferRect(srcBuffer, dstBuffer, srcX, srcY, dstX, dstY, w, h, pitch) {

// The row pitch could be different for source and destination,

// but is assumed to be the same in this example.

queue.enqueueCopyBufferRect(srcBuffer, dstBuffer, [srcX, srcY], [dstX, dstY],

[w, h], pitch, 0, pitch, 0);

};

6.6. WebCLMemoryObject

interface WebCLMemoryObject {


void release();

};

any getInfo(CLenum name) (OpenCL 1.1 §5.4.1, clGetMemObjectInfo)

name return type return value

`MEM_TYPE` `CLenum` `MEM_OBJECT_BUFFER` 또는

`MEM_OBJECT_IMAGE2D`

`MEM_FLAGS` `CLenum` 생성시간에 지정된 memFlags

`MEM_SIZE` `CLuint` 객체에 할당된 메모리의 바이트 크기

`MEM_CONTEXT` `WebCLContext` 메모리 객체의 WebCL

컨텍스트(context)

`MEM_ASSOCIATED_MEMOBJECT` `WebCLBuffer`

버퍼가 createSubBuffer을 사용하여

생성되었거나, 그렇지 않아서 null 인

버퍼 객체

`MEM_OFFSET` `CLuint`

createSubBuffer를 사용하여

생성되었거나 그렇지 않아서 0인

오프셋(offset)

예외:

INVALID_VALUE – name이 위 표에 있지 않은 유효한 열거값 중의 하나가 아닐 경우

void release() (OpenCL 1.1 §5.4.1, clReleaseMemObject)

이 객체에 의해서 사용중인 리소스를 해제한다.

6.6.1. WebCLBuffer

interface WebCLBuffer : WebCLMemoryObject {

WebCLBuffer createSubBuffer(CLenum memFlags, CLuint origin, CLuint sizeInBytes);

};


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetMemObjectInfo.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clReleaseMemObject.html


TTAK.OT-10.0390 ３４

WebCLBuffer createSubBuffer(CLenum memFlags, CLuint origin, CLuint sizeInBytes) (OpenCL

1.1 §5.2.1, clCreateSubBuffer)

WebCLBuffer의 서브 영역(sub-region)을 표시하는 새로운 WebCLBuffer를 생성한다. 이 두

버퍼는 글로벌 메모리의 동일한 영역을 참조하며, 변경이 발생하면 다른쪽에서 즉시 반영된다.

예외:

INVALID_MEM_OBJECT – WebCLBuffer가 이미 서브 버퍼(sub-buffer) 객체일 경우

INVALID_VALUE – memFlags이 MEM_READ_WRITE, MEM_WRITE_ONLY, 또는

MEM_READ_ONLY이 아닐 경우

INVALID_VALUE – origin, sizeinBytes에 의해서 지정된 영역이 WebCLBuffer의 범위 밖일

경우

MISALIGNED_SUB_BUFFER_OFFSET – 주어진 orgin 값이 잘못 정렬된 서브 버퍼(sub-

buffer)의 결과로 WebCLBuffer에 연결된 WebCLContext에 WebCLDevice가 있을 경우

6.6.2. WebCLImage

interface WebCLImage : WebCLMemoryObject {

WebCLImageDescriptor getInfo();

};

WebCLImageDescriptor getInfo() (OpenCL 1.1 §5.3.6, clGetImageInfo)

WebCLImage의 픽셀(pixel) 포맷(format)과 크기에 대한 정보를 포함하는 새로운

WebCLImageDescriptor를 반환한다.

6.7. WebCLSampler

interface WebCLSampler {

any getInfo(CLenum name); void release();

};

any getInfo(CLenum name) (OpenCL 1.1 §5.5.2, clGetSamplerInfo)

name 반환 유형

SAMPLER_CONTEXT WebCLContext

SAMPLER_NORMALIZED_COORDS CLboolean

SAMPLER_ADDRESSING_MODE CLenum

SAMPLER_FILTER_MODE CLenum

예외:

INVALID_VALUE – name이 위 표에 있는 유효한 열거값들 중에 하나가 아닐 경우

void release() (OpenCL 1.1 §5.5.1, clReleaseSampler)




http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clCreateSubBuffer.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetImageInfo.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetSamplerInfo.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clReleaseSampler.html


TTAK.OT-10.0390 ３５

6.8. WebCLProgram

interface WebCLProgram {


any getBuildInfo(WebCLDevice device, CLenum name);

void build(optional sequence<WebCLDevice>? devices,

optional DOMString? options,

optional WebCLCallback whenFinished);

WebCLKernel createKernel(DOMString kernelName);

sequence<WebCLKernel> createKernelsInProgram();

void release();

};

any getInfo(CLenum name) (OpenCL 1.1 §5.6.5, clGetProgramInfo)

name 반환 유형

PROGRAM_CONTEXT WebCLContext

PROGRAM_NUM_DEVICES CLuint

PROGRAM_DEVICES sequence<WebCLDevice>

PROGRAM_SOURCE DOMString

예외:

INVALID_VALUE - name이 위 표에 있는 유효한 열거값들 중에 하나가 아닐 경우

any getBuildInfo(WebCLDevice device, CLenum name) (OpenCL 1.1 §5.6.5,

clGetProgramBuildInfo)

name return type

PROGRAM_BUILD_STATUS CLint

PROGRAM_BUILD_OPTIONS DOMString

PROGRAM_BUILD_LOG DOMString

예외:

INVALID_DEVICE – device가 WebCLProgram과 연결되지 않았을 경우

INVALID_VALUE - name이 위 표에 있는 유효한 열거값들 중에 하나가 아닐 경우

void build(optional sequence<WebCLDevice>? devices, optional DOMString? options, optional

WebCLCallback whenFinished) (OpenCL 1.1 §5.6.2, clBuildProgram)

WebCLProgram에 의해서 생성되고 WebCLContext에 연결된 모든 단말기에 대해서,

주어진 단말기 목록이 있거나 또는 없어도 WebCLProgram을 컴파일한다.

컴파일 조건의 문자열과 빌드가 완료될 때 발생하는 비동기 콜백(callback) 기능이 또한


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetProgramInfo.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetProgramBuildInfo.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clBuildProgram.html


TTAK.OT-10.0390 ３６

제공된다. 자바스크립트 메인 스레드(thread)의 차단의 피하기 위하여 애플리케이션은

강력하게 콜백(callback)을 제공하도록 권고된다. 가능한 컴파일러 조건은 아래 표에

보였으며, 다른 조건을 유효하지 않은것으로 생각한다.

빌드(build) 조건 설명

-D name #define name in OpenCL C와 동일

-D name=definition #define name definition in OpenCL C와 동일

-cl-opt-disable 최적화를 위해 사용하지 않음.

-cl-single-

precision-constant double-precision 상수를 single-precision 처리

-cl-denorms-are-

zero Allow 비정상적인 숫자를 0으로 처리하는 것을 허용

-cl-mad-enable 잠재적인 낮은 정확도(potentially reduced accuracy)로 계산하기

위하여 a*b+c를 허용

-cl-no-signed-

zeros 최적화를 0의 부호화(signedness of zero)를 무시하는 것을 허용

-cl-unsafe-math-

optimizations

최적화를 위해서 IEEE 754와 OpenCL 숫자 준용 요구사항을 어기는

것을 허용. 이 조건은 -cl-no-signed-zeros와 cl-mad-enable

포함한다.

-cl-finite-math-only 최적화를 위해서 NaNs와 인파이니티(infinity)를 무시하는 것을 허용

-cl-fast-relaxed-

math -cl-finite-math-only 와 -cl-unsafe-math-optimizations 동일

-w 모든 경고 메시지의 금지

-Werror 모든 경고를 에러로 변경

예외:

INVALID_VALUE - devices.length === 0 일 경우

INVALID_DEVICE - devices에 있는 요소가 유효한 WebCLDevice가 아닐 경우

INVALID_DEVICE – devices에 있는 단말기가 이 WebCLProgram의 WebCLContext와

연결되지 않은 경우

INVALID_BUILD_OPTIONS – options에 의해 지정된 빌드조건이 잘못 지정된 경우

INVALID_OPERATION – devices에 있는 단말기에 대한 WebCLProgram의 이전 빌드가

완료되지 않았을 경우

BUILD_PROGRAM_FAILURE – 프로그램 실행을 위한 빌드가 실패할 경우

INVALID_OPERATION - WebCLKernel 객체가 이미 WebCLProgram에 포함되어 있을

경우

INVALID_OPERATION – 기능의 차단 폼(form)이 WebCLCallback으로 부터 호출되었을

경우

WebCLKernel createKernel(DOMString name) (OpenCL 1.1 §5.7.1, clCreateKernel)


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clCreateKernel.html


TTAK.OT-10.0390 ３７

Exceptions:

INVALID_PROGRAM_EXECUTABLE – WebCLProgram에 있는 단말기에 대해서

성공적으로 빌드가 되지 않은 경우

INVALID_KERNEL_NAME – 주어진 name의 커널(kernel)이 WebCLProgram에서

발견되지 않은 경우

INVALID_KERNEL_DEFINITION – 인수의 숫자와 인수 유형 등과 같은 주어진

커널(kernel) 기능(name)의 기능 정의가 실행 프로그램이 빌드되었을 때 모든

단말기에서 동일하지 않을 경우

sequence<WebCLKernel> createKernelsInProgram() (OpenCL 1.1 §5.7.1,

clCreateKernelsInProgram)

Exceptions:

INVALID_PROGRAM_EXECUTABLE – WebCLProgram에 있는 모든 단말기에 대해서

실행 프로그램의 빌드가 성공하지 못한 경우

void release() (OpenCL 1.1 §5.6.1, clReleaseProgram)


6.9. WebCLKernel

아래 메소드(method)는 커널(kernel) 실행인자 설정에 대한 방법과 커널(kernel) 중심

의 정보를 요청하는 것이다.

interface WebCLKernel {


any getWorkGroupInfo(WebCLDevice device, CLenum name);

WebCLKernelArgInfo getArgInfo(CLuint index);

void setArg(CLuint index, WebCLMemoryObject value);

void setArg(CLuint index, WebCLSampler value);

void setArg(CLuint index, ArrayBufferView value);void release();

};

any getInfo(CLenum name) (OpenCL 1.1 §5.7.3, clGetKernelInfo)

name return type

KERNEL_FUNCTION_NAME DOMString

KERNEL_NUM_ARGS CLuint

KERNEL_CONTEXT WebCLContext

KERNEL_PROGRAM WebCLProgram

예외:

INVALID_VALU` - name이 위 표에 있는 유효한 열거값들 중에 하나가 아닐 경우


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clCreateKernelsInProgram.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clReleaseProgram.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetKernelInfo.html


TTAK.OT-10.0390 ３８

any getWorkGroupInfo(WebCLDevice device, CLenum name) (OpenCL 1.1 §5.7.3,

clGetKernelWorkGroupInfo)

주어진 device와 nameReturns 에 해당되는 값

name return type

KERNEL_WORK_GROUP_SIZE CLuint

KERNEL_COMPILE_WORK_GROUP_SIZE sequence<CLuint>

KERNEL_LOCAL_MEM_SIZE CLuint

KERNEL_PREFERRED_WORK_GROUP_SIZE_MULTIPLE CLuint

KERNEL_PRIVATE_MEM_SIZE CLuint

Exceptions:

INVALID_DEVICE – WebCLKerner에 연결되지 않은 device일 경우

INVALID_DEVICE – device가 null이지만, WebCLKerner에 연결된 WebCLDevice가 하나

이상일 경우

INVALID_VALUE – name이 위 표에 있는 유효한 열거값들 중 하나가 아닐 경우

WebCLKernelArgInfo getArgInfo(CLuint index) (OpenCL 1.2 §5.7.3, clGetKernelArgInfo)

주어진 index에 있는 커널(kernel) 인수의 이름, 유형, 인증자를 가져온다. 커널에 의해서

선언된 인수의 전체 값이 N일때 Index 범위의 공식적인 값의 범위는 0에서 N-1 사이이다.

예외:

INVALID_ARG_INDEX – index가 WebCLKernel의 유효한 인수 인덱스(index)가 아닐 경우

void setArg(CLuint index, WebCLMemoryObject memObject) (OpenCL 1.1 §5.7.2,

clSetKernelArg)

주어진 index에 있는 커널(kernel) 인수의 memObject를 설정한다. 커널에 의해서 선언된

인수의 전체 값이 N일때 Index 범위의 공식적인 값의 범위는 0에서 N-1 사이이다

Exceptions:

INVALID_ARG_INDEX - WebCLKerner에 연결된 유효한 index가 아닐 경우

INVALID_ARG_VALUE – index에 있는 예상한 커널(kernel) 인수가 메모리 객체가 아닐

경우

INVALID_MEM_OBJECT – memObject가 유효한 WebCLMemoryObject가 아닐 경우

void setArg(CLuint index, WebCLSampler sampler) (OpenCL 1.1 §5.7.2, clSetKernelArg)

주어진 index에 있는 커널(kernel) 인수의 sampler를 설정한다. 커널에 의해서 선언된

인수의 전체 값이 N일때 Index 범위의 공식적인 값의 범위는 0에서 N-1 사이이다

Exceptions:



http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetKernelWorkGroupInfo.html


http://www.khronos.org/registry/cl/sdk/1.2/docs/man/xhtml/clGetKernelArgInfo.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clSetKernelArg.html




TTAK.OT-10.0390 ３９

INVALID_ARG_VALUE - index에 있는 예상한 커널(kernel) 인수가 샘플러(sampler) 가

아닐 경우

INVALID_SAMPLER - sampler가 유효한 WebCLSampler가 아닐 경우

void setArg(CLuint index, ArrayBufferView value) (OpenCL 1.1 §5.7.2, clSetKernelArg)

주어진 index에 있는 커널(kernel) 인수의 value를 설정한다. 커널에 의해서 선언된 인수의

전체 값이 N일때 Index 범위의 공식적인 값의 범위는 0에서 N-1 사이이다

value의 길이와 형은 대상 커널(kernel) 인수의 벡터(vector) 폭과 기본형이 같아야 한다.

예를 들어서, 만약 커널(kernel) 인수가 float4이면, value는 반드시 길이 4dml

Float32Array가 되어야 한다. local에 주소 공간 인증자의 인수는 바이트로 할당된 수를

지정하는 길이 1의 Unit32Array를 사용하여 설정되어야만 한다. ArrayBufferView의 64 비트

정수 변수는 사용되지 않기 때문에, 64 비트 정수는 부호가 없는 32 비트 정수의 쌍으로

사용되어야 한다. 하위 32 비트는 각 쌍의 첫번째 요소에 저장되며, 상위 32 비트는 두번째

요소에 저장된다.

예외:


INVALID_ARG_VALUE - index에 있는 예상한 커널(kernel) 인수가 스칼라(scalar),

벡터(vector) 또는 로컬 메모리 크기가 아닐 경우

INVALID_ARG_VALUE - value.length가 1, 2, 3, 4, 8, 16, 또는 32가 아닐 경우

INVALID_ARG_VALUE - value.length가 index에 있는 커널(kernel) 인수의 벡터(vector)

폭과 다르거나, 64비트 정수 인수에 대해서는 벡터(vector) 폭이 2배가 아닐 경우

INVALID_ARG_VALUE – index에 있는 커널(kernel) 인수가 local 주소 공간 인증자가

있으며, value가 Unit32Array의 길이가 1이 아닐 경우

void release() (OpenCL 1.1 §5.7.1, clReleaseKernel)

이 객체의 의해서 사용된 리소스를 해제한다.

예제 7

myKernel.setArg(0, 3.14159); // ERROR: 허가되지 않은 Number의 전달

myKernel.setArg(0, new Float32Array([3.14159])); // 3.14159를 float 캐스트(cast), 그 뒤에

arg #0로 kernel에 전달

myKernel.setArg(1, new Uint32Array([1.23, 2.34])); // 숫자를 uint2로 캐스트(cast), 그 뒤에

arg #1로 kernel에 전달

myKernel.setArg(2, new Uint32Array([512])); // arg #2에 대해서 512 바이트를 로컬

메모리를 예약

myKernel.setArg(3, myImage); // arg #3로 myImage를 kernel에 전달

6.9.1. WebCLKernelArgInfo

dictionary WebCLKernelArgInfo {




http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clReleaseKernel.html


TTAK.OT-10.0390 ４０

DOMString name;

DOMString typeName; // 'char', 'float', 'uint4', 'image2d_t', 'sampler_t', etc.

DOMString addressQualifier; // 'global', 'local', 'constant', or 'private'

DOMString accessQualifier; // 'read_only', 'write_only', or 'none'

};

DOMString name

커널(kernel) 인수에 대한 이름. 예를 들어서, srcPixels 또는 foobarCoefficient.

DOMString typeName (OpenCL 1.1 §6.1, Data types)

일반화된 형태의 커널(kernel) 인수의 데이터 유형. 예를 들어서, uint4 또는 image2d_t.

DOMString addressQualifier (OpenCL 1.1 §6.5, Address space qualifiers)

일반화된 형태의 커널(kernel) 인수의 어드레스(address) 공간 평가자(qualifier). 다시 말해서,

언더스코어(underscore)로 고정되지 않은 형태. 가능한 값은 global, local, constant, private.

DOMString accessQualifier (OpenCL 1.1 §6.6, Access qualifiers)

접근 평가자(qualifier)

일반화된 형태의 커널(kernel) 인수의 어드레스(address) 공간 평가자(qualifier). 다시 말해서,

언더스코어(underscore)로 고정되지 않은 형태. 만약 typeName이 image2d_t이면, 가능한

값은 read_only 이나 write_only이다. 다른 경우에 값은 none이다.

6.10. WebCLEvent

[Constructor]

interface WebCLEvent {


any getProfilingInfo(CLenum name);

void setCallback(CLenum commandExecCallbackType, WebCLCallback notify);

void release();

};

WebCLEvent()

enqueue 메소드(method)의 하나로써, 사용할 WebCLEvent 인스턴스(instance)를 생성한다.

새로 생성될 이벤트의 특성은 아래 표에 지정되어 있다. 각 WebCLEvent 인스턴스는

한번만 사용될 수 있다. 만약에 이미 사용하는 이벤트가 전달되어 있다면, enqueue

메소드(method)는 INVALID_EVENT 예외를 전송할 것이다. 사용자 이벤트는 이전에 사용된

것으로 생각하며, 재사용하지는 못한다.

name 반환 유형


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/dataTypes.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/constant.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/accessQualifiers.html


TTAK.OT-10.0390 ４１

EVENT_COMMAND_QUEUE undefined

EVENT_CONTEXT undefined

EVENT_COMMAND_TYPE undefined

EVENT_COMMAND_EXECUTION_STATUS -1

any getInfo(CLenum name) (OpenCL 1.1 §5.9, clGetEventInfo)

name 반환 유형

EVENT_COMMAND_QUEUE WebCLCommandQueue

EVENT_CONTEXT WebCLContext

EVENT_COMMAND_TYPE CLenum

EVENT_COMMAND_EXECUTION_STATUS CLint

예외:

INVALID_VALUE – name이 위 표에 있는 유효한 열거값 중에 하나가 아닐 경우

any getProfilingInfo(CLenum name) (OpenCL 1.1 §5.12, clGetEventProfilingInfo)

name 반환 값

PROFILING_COMMAND_QUEUED CLuint

PROFILING_COMMAND_SUBMIT CLuint

PROFILING_COMMAND_START CLuint

PROFILING_COMMAND_END CLuint

예외:

PROFILING_INFO_NOT_AVAILABLE - QUEUE_PROFILING_ENABLE 플래그(flag)가

WebCLCommandQueue에 대해서 설정되지 않았을 경우

PROFILING_INFO_NOT_AVAILABLE - WebCLEvent의 실행 상태가 COMPLETE가 아닐

경우

PROFILING_INFO_NOT_AVAILABLE – WebCLEvent가 사용자 이벤트 객체일 경우

INVALID_VALUE - name이 위 표에 있는 유효한 열거값 중에 하나가 아닐 경우

void setCallback(CLenum commandExecCallbackType, WebCLCallback notify) (OpenCL 1.1

§5.9, clSetEventCallback)

WebCLEvent가 주어진 commandExecCallbackType 상태 (COMPLETE, RUNNING,

SUBMITTED, 또는 QUEUED)가 되었을때 notify가 호출되어 WebCallback 기능을 설정함. 이

WebCL 버전에서는 COMPLETE 상태만 지원됨

예외:

INVALID_VALUE – commandExecCallbackType이 COMPLETE가 아닐 경우

void release() (OpenCL 1.1 §5.9, clReleaseEvent)



http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetEventInfo.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clGetEventProfilingInfo.html



http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clSetEventCallback.html


http://www.khronos.org/registry/cl/sdk/1.1/docs/man/xhtml/clReleaseEvent.html


TTAK.OT-10.0390 ４２

6.10.1. WebCLUserEvent

interface WebCLUserEvent : WebCLEvent {

void setStatus(CLint executionStatus);

};

void setStatus(CLint executionStatus) (OpenCL 1.1 §5.9, clSetUserEventStatus)

예외:

INVALID_VALUE – executionStatus가 COMPLETE가 아니거나 음의 정수값일 경우

INVALID_OPERATION – 이벤트 실행 상태가 setStatus의 이전 호출에 의해서 이미 변경된

경우

7. 확장

WebCL 구현은 핵심 기능의 몇 개로 확장될 수 있다. 이 확장들은 WebCL Extension

Registry 에서 문서로 만들어지고, 목록화 되어 있다. 표준화 진행상태에도 불구하고 각

확장은 사용하기 전에 애플리케이션에 의해서 명확하게 사용 가능해야 한다. 이 정책은

일반적으로 사용하지 않는 기능들의 의도하지 않는 사용의 최소화를 목표로 하고 있다.

가능한 확장의 셋은 동일한 시스템에서도 하나의 WebCLDevice 로부터 다른 곳으로,

하나의 WebCLPlatform 에서 다른 곳으로 다양할 수 있다. 예를 들어서, WebGL

Resource Sharing 확장은 CPU 가 아니 GPU 에 의해서 지원된다. 시스템에 전반에서

지원되는 확장 이름은 webcl.getSupportExtensions()과 함께 요청할 수 있다. 유사하게

특정한 WebCLPlatform 에서 get.SupportedExtensions 을 호출하여 해당 플랫폼에서

지원하는 모든 장치 확장 셋(set)을 반환 받을 수 있다. 최종적으로, 각 WebCLDevice

의 getSupportedExtensions() 그 다바이스에서 지원하는 확장 셋(set)을 돌려준다.

WebCL 확장은 문자열 매개 변수로 원하는 확장의 이름과 같이 enableExtension 을

호출하여 사용할 수 있다. 이것은 만약 확장이 성공적으로 되면 true 를 반환하며, 만약

아니면 false 를 반환한다. 이와 관련된 예제는 아래를 보기 바란다.

예제 8

// 모든 WebCL 단말기를 반복하고, 사용가능한 확장과 같이 주어진 확장

// 지원에 대한것을 반환한다.

//

function getDevicesWithExtensionEnabled(extensionName) {

var devices = [];

webcl.getPlatforms().forEach(function(platform) {

platform.getDevices().forEach(function(device) {

var isSupported = device.enableExtension(extensionName);


TTAK.OT-10.0390 ４３

if (isSupported) devices.push(device);

});

});

return devices;

}

예제 9

// KHR_fp64와 KHR_gl_sharing 모두를 지원하는 단말기의 찾아서 위 기능을 사용한다.

//

var withFP64 = getDevicesWithExtensionEnabled("KHR_fp64");

var withGL = getDevicesWithExtensionEnabled("KHR_gl_sharing");

var withBoth = withGL.filter(function(v) { return (withFP64.indexOf(v) !== -1) });

8. 보안 및 로버스트니스(robustness)

WebCL은 보안을 가장 우선으로 고려하여 설계되었다. 이 장은 적합한 WebCL 구현을

위해 반드시 따라야 하는 주요 보안 요구 사항들을 정의한다.

8.1. 범위를 벗어난 메모리 접근 (Out-of-Bounds Memory Access)

WebCL 커널은 어드레스 공간(private, local, global, 또는 constant)에도 불구하고

허가받지 않는 메모리 영역에 접근할 수 없다. 만일 컴파일 동안에 범위를 벗어난

접근은 컴파일 에러를 생성한다. 실행 시에는 OOB(Out-of-Bounds)에 대한 읽기는 0을

반환하고, 쓰기는 버려져야만 한다. 다른 방법으로는 커널은 종료시키고, 예외 처리를

발생시킨다.

바운드(bound) 확인을 목적으로, 구현할 때에는 각 변수를 따로 바운드를 강요하는

대신에 local 변수와 유사하게 인접한 메모리 블록을 모든 private 변수로 처리할 수 있

다. 예를 들어서, 커널 프로그램은 두 개의 private 배열을 가지고 있고, 첫 번째 배열로

부터 OOB 읽기는 0을 아닌, 첫 번째나 두 번째 배열로부터 어떤 값을 반환하는 것을

허용된다.

WebCL 커널의 측정 (instrumentation), 분석 및 확인 (validation)을 통해서 범위를 벗

어난 메모리 접근을 차단하기 위한 WebCL Validator 오픈 소스 프로젝트가 WebCL 워

킹 그룹(working group) 에 의해서 시작되었다. 이 Validator는 로컬 및 프라이비트

(private) 메모리의 초기화를 강제한다. (Khronos WebCL Project)

8.2. 메모리 초기화

애플리케이션이 이전 애플리케이션이 남겨둔 데이터를 검사하지 못하게 보증하기 위하

https://github.com/KhronosGroup/webcl-validator


TTAK.OT-10.0390 ４４

여 WebCL 구현방법은 다른 애플리케이션들이 읽기를 위해서 접근을 하기 전에 버퍼들

과 변수들을 0으로 초기화해야만 한다. 이 요구사항은 어드레스 공간(private, local,

global, 또는 constant)에 상관없이 적용되며, 할당이 커널 코드나 호스트 코드의 존재

유무에 상관없이 적용되어야 한다.

OpenCL 1.2 확장 cl_khr_initialize_memory이 가능한 곳에서는 WebCL 구현은 커널이

실행되기 전에 효과적이며 자동으로 로컬과 프라이비트(private) 메모리를 초기화한다

(OpenCL 1.2 Extension Specification).

8.3. 서비스 거부(Denial of Service)

오랫동안 실행되거나 연산이 많은 커널 (또는 명령 큐에 있는 다른 명령)은 장치 리소

스를 불균형하게 사용함에 따라 시스템이 반응하지 않게 될 수 있다. 일반적으로 이러한

문제를 브라우저나 WebCL 수준에서 막을 수는 없다. 와치독 타이머(watchdog time)와

선점적 멀티태스킹과 같은 메커니즘이 필요하며, OpenCL 드라이버와 운영체제에서 이러

한 것이 제공되어야만 한다. 필요한 지원이 가능한 시스템에서는 WebCL 구현은 아래 내

용을 사용할 수 있도록 강력하게 요구하고 있다.

1. 문제가 있는 커널과 다른 명령의 감지. 명령어는 만약 과도하게 오랜 시간 동안

실행되거나 시스템 리소스를 불균형하게 사용하면 문제가 있는 것으로 판단함

2. OpenCL 디바이스가 반응이 없거나 잠재적인 장치 초기화를 초래하기 전에 문제

가 있는 명령어와 관련된 컨텍스트(context)를 종료함

OpenCL 1.2 확장 cl_khr_terminate_context가 가능한 곳에서 예를 들어서, 컨텍스트

(context)가 너무 오랫동안 동작 중이고, 프로그램이 예외 처리로 인해서 종료된 컨텍스트

와 관련된 하나 이상의 커널이 있다면 컨텍스트(context)의 빠른 종료에 사용할 수 있다

(OpenCL 1.2 Extension Specification).

9. 개발 노트

WebCL이 OpenCL1.1 (Embedded Profile)을 기반으로 하고 있지만, OpenCL 1.2의 상

단부(top)나 OpenCL 1.1과 호환성이 남아 있는 차기 버전으로 개발될 수 있다. 하지만,

개발된 것이 OpenCL 1.2 나 그 뒤 버전에서 운영되더라도, 나중에는 WebCL을 지원하

지 않는 특정 기능을 사용하지 않는지를 애플리케이션이 이 기능을 사용하는지를 반드시

확인해야 한다. 이것은 특별히 이 개발이 WebCL에 따라서 커널 코드가 유효한지를 먼저

https://www.khronos.org/registry/cl/specs/opencl-1.2-extensions.pdf

https://www.khronos.org/registry/cl/specs/opencl-1.2-extensions.pdf


TTAK.OT-10.0390 ４５

확인하지 않은 경우, 이를 포함한 중요한 OpenCL 컴파일러 커널 코드를 전달하지 않아

야만 한다는 것을 의미한다. 예를 들어서, printf가 지원하지 않는 WebCL에서 printf()의

사용은 컴파일 에러로 반드시 처리되어야만 한다.

WebCL 규격과 적합성 테스트는 OpenCL 호환되는 드라이버들에 근거하여 개발한다는

가정하에 작성되었다. 구현방법에서 어떤 보안이나 안정화 문제들을 쉽게 제거하기 위하

여 동작하지 않거나 취약점이 있는 OpenCL 드라이버에 대한 동적인 블랙리스트(black-

list) 사용하는 것을 강력히 권고한다.

WebCL 객체는 일반적인 자바스크립트 객체이며, 이와 같이 동작해야 한다. 예를 들어

서, 애플리케이션 임의의 속성과 기능을 첨부한다면, 만약 같은 객체를 두 번 가져오는

것이다. 인스턴스(instance)는 ‘===’ 연산자에 따라 같은 것을 반환해야 한다. 예를 들어

서, 다음의 검증(assertion) 코드 예제는 반드시 참(true)이어야 한다.

예제 10.

var ctx = webcl.createContext();

ctx.name = "myContext";

var queue = ctx.createCommandQueue();

var ctx2 = queue.getInfo(WebCL.QUEUE_CONTEXT);

ASSERT(ctx2 === ctx);

ASSERT(ctx2.name === "myContext");

10. WebCL과 OpenCL 1.1의 차이점

이 장은 OpenCL 1.1 임베디드 프로파일과 OpenCL C 와 관련된 WebCL API 와

WebCL C 커널 프로그래밍 언어와 차이에 대해서 설명한다. 그 차이점은 아래와 같다.

2D image support is required

3D images are not supported

The ADDRESS_NONE sampler addressing mode is not supported

Mapping of CL memory objects into host memory space is not supported

Program binaries are not supportedThe following OpenCL API functions are

not supported:

o clEnqueueTask

o clEnqueueNativeKernel

o clCreateImage3D

o clCreateProgramWithBinary

o clEnqueueMapBuffer

o clEnqueueMapImage


TTAK.OT-10.0390 ４６

o clEnqueueUnmapMemObject

o clSetMemObjectDestructorCallback

o clUnloadCompiler

Structures are not supported as kernel arguments

Calling a kernel function from another kernel function is not supported

Identifiers in WebCL C must be less than 256 characters

The goto keyword is not supportedThe following OpenCL C built-in functions

and are not supported:

o async_work_group_copy

o async_work_group_strided_copy

o wait_group_events


TTAK.OT-10.0390 ４７

표준 작성 공헌자

표준 번호 : TTAK.OT-10.0390

이 표준의 제정‧개정 및 발간을 위해 아래와 같이 여러분들이 공헌하였습니다.

구분 성명 위원회 및 직위 연락처

(E-mail 등) 소속사

표준(과제)

제안 홍덕기

웹 프로젝트그룹

위원 [email protected]

(사)HTML5

융합기술포럼

표준 초안

작성자 홍덕기

웹 프로젝트그룹

위원 [email protected]

(사)HTML5

융합기술포럼

표준 초안

에디터 이재호 - [email protected] ETRI

표준 초안

검토

이승윤 웹 프로젝트그룹

의장 [email protected] ETRI

외 프로젝트그룹

위원

표준안

심의

박승민 소프트웨어/콘텐츠

기술위원회 의장 [email protected] ETRI

외 기술위원회 위원

사무국 담당

김영화 - [email protected] TTA

이혜진 - [email protected] TTA


병렬 처리를 위한 웹 컴퓨팅 언어-WebCL 1.0 (WebCL 1.0)

발행인 : 한국정보통신기술협회 회장

발행처 : 한국정보통신기술협회

463-824, 경기도 성남시 분당구 분당로 47

Tel : 031-724-0114, Fax : 031-724-0109

발행일 : 2015.12.

T T A S t a n d a r d - tta.or.krLanguage)와 유사한 표준화된 자바스크립트(Javascript)...

Documents

Transcript of T T A S t a n d a r d - tta.or.krLanguage)와 유사한 표준화된 자바스크립트(Javascript)...