Intel® System Studio 2015 Beta for Linux Hosts Silent Installation Guide

Embedded

Architettura Intel® Many Integrated Core

Per iniziare

Area tema:

IDZone

↧

Asynchronous Offload - C++ Code Examples

September 26, 2014, 10:23 am

Latest and popular articles on Intel Technologies

≫ Next: Asynchronous Offload - Fortran Code Examples

≪ Previous: Intel® System Studio 2015 Beta for Linux Hosts Silent Installation Guide

This document provides information about asynchronous data transfer, asynchronous computation and memory management without data transfer. This document includes code examples of common usage scenarios. The examples in this article are in C/C++ only.

Introduction

Two different C++ pragmas are used for data transfer and wait for completion.
The pragma for data transfer only, with asynchronous option is:

#pragma offload_transfer <clauses> [ signal(<tag>) ]

The pragma to wait for completion of asynchronous activity is

#pragma offload_wait <clauses> wait(<tag>)

The offload pragma also takes optional signal/wait clauses

#pragma offload <clauses> [ signal(<tag>) ] [ wait(<tag>) ]<statement>

The offload_transfer and offload_wait pragmas are stand-alone and do not apply to the subsequent code block.

Data Transfer

The offload_transfer pragma is a stand-alone pragma, meaning that no statement succeeds it. This pragma contains a target clause and either all in clauses, or all out clauses. Without a signal clause, offload_transfer initiates and completes a synchronous data transfer. With a signal clause, initiates the data transfer only. The offload_transfer pragma can also take a wait clause. A later pragma with wait clause is used to wait for data transfer completion. Expressions in signal and wait clauses are address-sized values that serve as tags on the asynchronous operation.

// Example 1:
// Synchronous data transfer CPU -> MIC
// Next statement executed after data transfer is completed
#pragma offload_transfer target(mic:0) in(a,b,c)

// Example 2:
// Initiate asynchronous data transfer CPU -> MIC
#pragma offload_transfer target(mic:0) in(a,b,c) signal(&a)

The offload_wait pragma is also a stand-alone pragma which does not require a succeeding statement. This pragma contains a target clause and a wait clause, which cause the pragma to start execution only after the asynchronous activity associated with the tag has completed.

// Example 3:
// Wait for activity signaled by &p to be completed. Variable p is the tag.
#pragma offload_wait target(mic:0) wait(&p)

Memory Management

The offload_transfer pragma can be used for memory allocation and deallocation by avoiding the data transfer with the use of the nocopy clause. This is typically done outside of a loop to amortize cost of allocation.

// Example 4:
#define ALLOC alloc_if(1) free_if(0)
#define FREE alloc_if(0) free_if(1)
#define REUSE alloc_if(0) free_if(0)
// Allocate memory on the coprocessor  (without also transferring data)
#pragma offload_transfer target(mic:0) nocopy(p,q : length(l) ALLOC)
…
for (…)
{
  // Use of allocated memory on the coprocessor for offloads
  #pragma offload target(mic:0) in(p:length(l) REUSE) out(q:length(l) REUSE)
  {
    // computation using p and q
    ...
  }
}
…
// Free memory on the coprocessor (without also transferring data)
#pragma offload_transfer target(mic:0) nocopy(p,q : length(l) FREE)

Send Input Data Asynchronously

The most typical usage begins with initiating the data transfer, execute some CPU activity, then start the offload computation that will use the transferred data. The data is placed in the same variables listed in the transfer initiation. Those variables must be accessible by the time the offload pragma begins execution.

// Example 5:
// Initiate asynchronous data transfer MIC -> CPU
#pragma offload_transfer target(mic:0) in(p,q,r) signal(&p)
…
…
// Do the offload only after data has arrived
#pragma offload target(mic:0) wait(&p)
{
  // offload computation… = p;
}

Receive Output Asynchronously

In asynchronous offload, an offload computation produces results that will be transferred back to the host at a later time. The offload pragma finishes the work but does not immediately copy the data back. Instead, an asynchronous offload_transfer initiates the copy. Later, when results are needed, an offload_wait is used to retrieve the data.

// Example 6a:
// Perform  the offload computation but don’t copy back results immediately
#pragma offload target(mic:0) nocopy(p)
{
  p = …;
}
// Initiate asynchronous data transfer MIC -> CPU
#pragma offload_transfer target(mic:0) out(p) signal(&p)
…
…
// Wait for data to arrive
#pragma offload_wait target(mic:0) wait(&p)

Asynchronous Computation

The host initiates an offload to be performed asynchronously and can proceed to next statement after starting this computation. Later in the code, an offload_wait pragma is used to wait for completion of the offload activity.

// Example 6b:
char signal_var;
int *p;
do {
// Initiate asynchronous computation
#pragma offload … in( p:length(1000) ) signal(&signal_var)
{
mic_compute();
}
concurrent_cpu_activity();
#pragma offload_wait (&signal_var);
} while (1);

Testing Signals

Some scenarios require testing to determine whether the computation signaled with a given tag is finished. Use the _Offload_signaled function (non-blocking mechanism) to check if an offload has completed.

// Example 7:
// Initiate asynchronous computation
int c;
#pragma offload target(mic:mic_no) signal(&c) ...
{
   S3;
}
...
// Test if computation has been completed for tag “c”
if _Offload_signaled(mic_no, &c) ….

Double-buffering

Use the offload, offload_transfer and offload_wait pragmas to implement a double-buffering algorithm. The example below shows memory allocation on the target device, asynchronous data transfers, the use of signal clauses to control asynchronous offloads.

// Example 8: Double-buffering Input
void do_async_in()
{
  int i;
  #pragma offload_transfer target(mic:0) in(in1 : length(count) REUSE) signal(in1)
  for (i=0; i<iter; i++)
  {
    if (i%2 == 0)
    {
      #pragma offload_transfer target(mic:0) if(i!=iter-1) \
        in(in2 : length(count) REUSE) signal(in2)

      #pragma offload target(mic:0) nocopy(in1) wait(in1) \
        out(out1 : length(count) REUSE)
         compute(in1, out1);
    } else {
      #pragma offload_transfer target(mic:0) if(i!=iter-1) \
        in(in1 : length(count) REUSE ) signal(in1)

      #pragma offload target(mic:0) nocopy(in2) wait(in2) \
        out(out2 : length(count) REUSE)
          compute(in2, out2);
    }
  }
}

// Example 8: Double-buffering Output
void do_async_out()
{
  int i;
  for (i=0; i<iter+1; i++)
  {
    if (i%2 == 0) {
      if (i<iter) {
        #pragma offload target(mic:0) in(in1 : length(count) REUSE) nocopy(out1)
          compute(in1, out1);
        #pragma offload_transfer target(mic:0) out(out1:length(count) REUSE) signal(out1)
      }
      if (i>0) {
        #pragma offload_wait target(mic:0) wait(out2)
          use_result(out2);
      }
    } else {
      if (i<iter) {
        #pragma offload target(mic:0) in(in2 : length(count) REUSE) nocopy(out2)
          compute(in2, out2);
        #pragma offload_transfer target(mic:0) out(out2:length(count) REUSE)) signal(out2)
      }
      if (i>0) {
        #pragma offload_wait target(mic:0) wait(out1)
          use_result(out1);
      }
    }
  }
}

Summary

Asynchronous offload allows data transfer and computation to overlap. This method does not require the use of additional threads on the host and is useful for pipelined operations. Refer to the following sample code installed with the Intel® C++ Compiler for more details (default installation directory):

Linux*: /opt/intel/composer_xe_2015/Samples/en_US/C++/mic_samples/intro_sampleC
Windows*: C:\Program Files (x86)\Intel\Composer XE 2015\Samples\en_US\C++

Compilatore C++ Intel®

Area tema:

IDZone

↧

Asynchronous Offload - Fortran Code Examples

September 26, 2014, 11:05 am

Latest and popular articles on Intel Technologies

≫ Next: Управление режимами вычислений с плавающей запятой при использовании Intel® Threading Building Blocks

≪ Previous: Asynchronous Offload - C++ Code Examples

Introduction

Two different Fortran directives are used for data transfer and wait for completion.
The directive for data transfer only, with asynchronous option is:

!dir$ offload_transfer <clauses> [ signal(<tag>) ]

The directive to wait for completion of asynchronous activity is

!dir$ offload_wait <clauses> wait(<tag>)

The offload directive also takes optional signal and wait clauses

!dir$ offload <clauses> [ signal(<tag>) ] [ wait(<tag>) ]<statement>

The offload_transfer and offload_wait directives are stand-alone and do not apply to the subsequent code block.

Data Transfer

The offload_transfer directive is a stand-alone directive, meaning that no statement succeeds it. This directive contains a target clause and either all in clauses, or all out clauses. Without a signal clause, offload_transfer initiates and completes a synchronous data transfer. With a signal clause, initiates the data transfer only. The offload_transfer directive can also take a wait clause. A later directive with wait clause is used to wait for data transfer completion.
Expressions in the signal and wait clauses are address-sized values that serve as tags on the asynchronous operation.

! Example 1
! Synchronous data transfer CPU -> MIC
! Next statement executed after data transfer is completed
!dir$ offload_transfer target(mic:0) in(a,b,c)

! Example 2
! Initiate asynchronous data transfer CPU -> MIC
!dir$ offload_transfer target(mic:0) in(a,b,c) signal(s)

The offload_wait directive is also a stand-alone directive which does not require a succeeding statement. This directive contains a target clause and a wait clause, which cause the directive to start execution only after the asynchronous activity associated with the tag has completed.

! Example 3
! Wait for activity signaled by &p to be completed. Variable p is the tag.
!dir$ offload_wait target(mic:0) wait(s)

Memory Management

The offload_transfer directive can be used for memory allocation and deallocation by avoiding the data transfer with the use of the nocopy clause. This is typically done outside of a loop to amortize cost of allocation.

! Example 4
#define ALLOC alloc_if(.TRUE.) free_if(.FALSE.)
#define FREE alloc_if(.FALSE.) free_if(.TRUE.)
#define REUSE alloc_if(.FALSE.) free_if(.FALSE.)
! Allocate memory on the coprocessor  (without also transferring data)
!dir$ offload_transfer target(mic:0) nocopy(p,q: ALLOC)
do …
    ! Use of allocated memory on the coprocessor for offloads
    !dir$ offload target(mic:0) in(p: REUSE) out(q: REUSE)
    ! computation using p and q
enddo
…
! Free memory on the coprocessor (without also transferring data)
!dir$ offload_transfer target(mic:0) nocopy(p,q: FREE)

Send Input Data Asynchronously

The most typical usage initiates the data transfer, executes some CPU activity, then starts the offload computation that will use the transferred data. The data is placed in the same variables listed in the transfer initiation. Those variables must be accessible by the time the offload directive begins execution.

! Example 5
! Initiate asynchronous data transfer MIC -> CPU
!dir$ offload_transfer target(mic:0) in(p,q,r) signal(s)
…
…
! Do the offload only after data has arrived
!dir$ offload target(mic:0) wait(s)
! offload computation
… = p

Receive Output Asynchronously

In asynchronous offload, an offload computation produces results that will be transferred back to the host at a later time. The offload directive finishes the work but does not immediately copy the data back. Instead, an asynchronous offload_transfer initiates the copy. Later, when results are needed, an offload_wait is used to retrieve the data.

! Example 6a
! Perform  the offload computation but don’t copy back results immediately
!dir$ offload target(mic:0) nocopy(p)
! offload computation
…
! Initiate asynchronous data transfer MIC -> CPU
!dir$ offload_transfer target(mic:0) out(p) signal(s)
…
…
! Wait for data to arrive
!dir$ offload_wait target(mic:0) wait(s)

Asynchronous Computation

The host initiates an offload to be performed asynchronously and can proceed to next statement after starting this computation. Later in the code, an offload_wait directive is used to wait for completion of the offload activity.

! Example 6b
character :: signal_var
integer, allocatable, dimension :: p
do …
! Initiate asynchronous computation
!dir$ offload … in(p) signal(signal_var)
    call mic_compute();
call concurrent_cpu_activity();
!dir$ offload_wait (signal_var);
enddo

Testing Signals

Some scenarios require testing to determine whether the computation signaled with a given tag is finished. Use the Offload_signaled function (non-blocking mechanism) to check if an offload has completed.

! Example 7
! Initiate asynchronous computation
program prog
use mic_lib
implicit none

integer :: c
!dir$ offload target(mic:mic_no) signal(c)
    ! offload computation statement
    ...
! Test if computation has been completed
if (Offload_signaled(mic_no, c) /= 0) then
    …
endif

Double-buffering

Use the offload, offload_transfer and offload_wait directives to implement a double-buffering algorithm. The example below shows memory allocation on the target device, asynchronous data transfers, the use of signal clauses to control asynchronous offloads.

! Example 8 - Double-buffering Input
subroutine do_async_in()
    integer :: i
    !dir$ offload_transfer target(mic:0) in(in1: REUSE) signal(sig1)
    do i=1, iter
        if (MOD(i, 2) == 1) then
            ! Odd numbered iterations
            !dir$ offload_transfer target(mic:0) if(i /= iter) in(in2: REUSE) signal(sig2)
            !dir$ offload target(mic:0) nocopy(in1) wait(sig1)  out(out1: REUSE)
            call compute(in1, out1);
        else
            !dir$ offload_transfer target(mic:0) if(I /= iter) in(in1: REUSE ) signal(sig1)
            !dir$ offload target(mic:0) nocopy(in2) wait(sig2) out(out2: REUSE)
            call compute(in2, out2);
        endif
    enddo
end subroutine

! Example 8 - Double-buffering Output
subroutine do_async_out()
    integer :: i
    do i=1, iter
        if(MOD(i, 2) ==1) then ! Odd numbered iterations
            if (i<iter) then ! all iterations except the last
                !dir$ offload target(mic:0) in(in1: REUSE) nocopy(out1)
                    call compute(in1, out1)
                !dir$ offload_transfer target(mic:0) out(out1: REUSE) signal(sig1)
             end if
             if (i>1) then ! all iterations except the first
                 !dir offload_wait target(mic:0) wait(sig2)
                 call use_result(out2)
             endif
         else ! even numbered iterations
             if(i < iter) then ! all iterations except the last
                 !dir$ offload target(mic:0) in(in2:REUSE) nocopy(sig2)
                 call compute(in2, out2)
                 !dir$ offload_transfer target(mic:0) out(out2:REUSE) signal(sig2)
             endif
            if(i > 1) then ! all iterations except the first
                !dir$ offload_wait target(mic:0) wait(sig1)
                call use_result(out1)
            endif
        endif
    enddo
end subroutine

Summary

Asynchronous offload allows data transfer and computation to overlap. This method does not require the use of additional threads on the host and is useful for pipelined operations. Refer to the following sample code installed with the Intel® Fortran Compiler for more details (default installation directory):

Linux*: /opt/intel/composer_xe_2015/Samples/en_US/Fortran/mic_samples/LEO_Fortran_intro
Windows*: C:\Program Files (x86)\Intel\Composer XE 2015\Samples\en_US\Fortran

Architettura Intel® Many Integrated Core

Area tema:

IDZone

↧

Управление режимами вычислений с плавающей запятой при использовании Intel® Threading Building Blocks

September 30, 2014, 4:14 am

Latest and popular articles on Intel Technologies

≫ Next: HTML5 Hybrid Apps with Admob* Cordova* plug-in

≪ Previous: Asynchronous Offload - Fortran Code Examples

В Intel® Threading Building Blocks (Intel® TBB) 4.2, обновление 4, появилась расширенная поддержка управления параметрами вычислений с плавающей запятой. Теперь эти параметры можно указать при вызове большинства параллельных алгоритмов (включая flow::graph). В этом блоге мне бы хотелось рассказать о некоторых особенностях, новых функциях и общей поддержке вычислений с плавающей запятой в Intel TBB. Этот блог не посвящен общей поддержке вычислений с плавающей запятой в ЦП. Если вы незнакомы с поддержкой вычислений с плавающей запятой в ЦП, рекомендую начать с раздела Операции с плавающей запятойв справочном руководстве Intel® C++ Compiler. Для получения дополнительных сведений о сложностях арифметики с плавающей запятой рекомендую классику “Все, что необходимо знать об арифметике с плавающей запятой”.

В Intel TBB предлагается два способа, при помощи которых можно задать нужные параметры вычислений с плавающей запятой для задач, выполняемых планировщиком задач Intel TBB:

Когда планировщик задач инициализируется для заданного потока приложения, он получает текущие параметры вычислений с плавающей запятой этого потока;
У класса task_group_context есть метод для получения текущих параметров вычислений с плавающей запятой.

Рассмотрим первый подход. Такой подход, по сути, является неявным: планировщик задач всегда и безусловно получает параметры вычислений с плавающей запятой в момент своей инициализации. Затем сохраненные параметры используются для всех задач, связанных с этим планировщиком задач. Другими словами, такой подход можно рассматривать как свойство планировщика задач. Поскольку это свойство планировщика задач, мы можем применять и управлять параметрами вычислений с плавающей запятой в нашем приложении двумя способами:

Планировщик задач создается для каждого потока, поэтому мы можем запустить новый поток, задать нужные параметры, а затем инициализировать для этого потока новый планировщик задач (явно или неявно), который получит параметры вычислений с плавающей запятой;
Если поток уничтожает планировщик задач и инициализирует новый, можно будет получить новые параметры. Можно указать новые параметры вычислений с плавающей запятой перед повторным созданием планировщика. При создании нового планировщик задач параметры будут применены для всех задач.

Я попробую показать некоторые особенности в следующих примерах:

Обозначения:

“fp0”, “fp1” and “fpx” – состояния, описывающие параметры вычислений с плавающей запятой;
“set_fp_settings( fp0 )” и “set_fp_settings( fp1 )” – указание параметров вычислений с плавающей запятой для текущего потока;
“get_fp_settings( fpx )” – получение параметров вычислений с плавающей запятой из текущего потока и сохранение этих параметров в “fpx”.

Пример #1. Планировщик задач по умолчанию.

// Suppose fp0 is used here.
// Every Intel TBB algorithm creates a default task scheduler which also captures floating-point
// settings when initialized.
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // fp0 will be used for all iterations on any Intel TBB worker thread.
} );
// There is no way anymore to destroy the task scheduler on this thread.

Пример #2. Настраиваемый планировщик задач.

// Suppose fp0 is used here.
tbb::task_scheduler_init tbb_scope;
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // fp0 will be used for all iterations on any Intel TBB worker thread.
} );

В целом, пример 2 действует так же, как пример 1, но зато предоставляет способ вручную завершить работу планировщика задач.

Пример #3. Повторная инициализация планировщика задач.

// Suppose fp0 is used here.
{
    tbb::task_scheduler_init tbb_scope;
    tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
        // fp0 will be used for all iteration on any Intel TBB worker thread.
    } );
} // the destructor calls task_scheduler_init::terminate() to destroy the task scheduler
set_fp_settings( fp1 );
{
    // A new task scheduler will capture fp1.
    tbb::task_scheduler_init tbb_scope;
    tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
        // fp1 will be used for all iterations on any Intel TBB worker
        // thread.
    } );
}

Пример #4. Еще один поток.

void thread_func();
int main() {
    // Suppose fp0 is used here.
    std::thread thr( thread_func );
    // A default task scheduler will capture fp0
    tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
        // fp0 will be used for all iterations on any Intel TBB worker thread.
    }
    thr.join();
}
void thread_func() {
    set_fp_settings( fp1 );
    // Since it is another thread, Intel TBB will create another default task scheduler which will
    // capture fp1 here. The new task scheduler will not affect floating-point settings captured by
    // the task scheduler created on the main thread.
    tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
        // fp1 will be used for all iterations on any Intel TBB worker thread.
    }
}

Обратите внимание, что Intel TBB может повторно использовать одни и те же рабочие потоки для обоих parallel_for, несмотря на то, что они вызваны из разных потоков. При этом гарантируется, что все итерации parallel_for в главном потоке будут использовать fp0, а все итерации второго parallel_for — fp1.

Пример #5. Изменение параметров вычислений с плавающей запятой в потоке пользователя.

// Suppose fp0 is used here.
// A default task scheduler will capture fp0.
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // fp0 will be used for all iterations on any Intel TBB worker thread.
} );
set_fp_settings( fp1 );
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // fp0 will be used despite the floating-point settings are changed before Intel TBB parallel
    // algorithm invocation since the task scheduler has already captured fp0 and these settings
    // will be applied to all Intel TBB tasks.
} );
// fp1 is guaranteed here.

Второй parallel_for оставит fp1 неизменным в пользовательском потоке (несмотря на то, что для всех итераций используется fp0), поскольку в Intel TBB гарантируется отсутствие изменений параметров вызывающего потока вызовом любого параллельного алгоритма Intel TBB, даже если алгоритм выполняется с другими параметрами.

Пример #6. Изменение параметров вычислений с плавающей запятой в задаче Intel TBB.

// Suppose fp0 is used here.
// A default task scheduler will capture fp0
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    set_fp_settings( fp1 );
    // Setting fp1 inside the task will lead undefined behavior. There are no guarantees about
    // floating-point settings for any following tasks of this parallel_for and other algorithms.
} );
// No guarantees about floating-point settings here and following algorithms.

Если вам очень нужно использовать внутри задачи другие параметров вычислений с плавающей запятой, следует записать предыдущие параметры, а в конце задачи восстановить их:

// Suppose fp0 is used here.
// A default task scheduler will capture fp0
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    get_fp_settings( fpx );
    set_fp_settings( fp1 );
    // ... some calculations.
    // Restore captured floating-point settings before the end of the task.
    set_fp_settings( fpx );
}
// fp0 is guaranteed here.

Для решения большей части проблем можно использовать подход с применением планировщика задач для управления параметров вычислений с плавающей запятой. Но представьте себе ситуацию, когда для каждой из двух частей вычисления требуются разные параметры. Разумеется, можно использовать подходы, показанные в примерах 3 и 4. Но при этом могут возникнуть определенные затруднения:

Реализация затруднена: в примере 3 невозможно управлять жизненным циклом объекта планировщика задач, а в примере 4 может потребоваться синхронизация между потоками;
Влияние на производительность: в примере 3 нужно заново инициализировать планировщик задач, тогда как ранее этого не требовалось, а в примере 4 может возникнуть проблема избыточной подписки.

Что происходит с вложенными вычислениями при разных параметрах вычислений с плавающей запятой? Применение планировщика задач в этом случае затрудняется, поскольку потребуется писать много бесполезного кода.

В Intel TBB 4.2 U4 появился новый подход на основе task_group_context: функциональность task_group_context была расширена для управления параметрами вычислений с плавающей запятой для задач, связанных с ним, с помощью нового метода

void task_group_context::capture_fp_settings();

получающего эти параметры из вызывающего потока и передающего их своим задачам. Таким образом, вы можете без труда задать нужные параметры для того или иного параллельного алгоритма:

Пример #7. Задание параметров вычислений с плавающей запятой для определенного алгоритма.

// Suppose fp0 is used here.
// The task scheduler will capture fp0.
task_scheduler_init tbb_scope;
tbb::task_group_context ctx;
set_fp_settings( fp1 );
ctx.capture_fp_settings();
set_fp_settings( fp0 );
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // In spite of the fact the task scheduler captured fp0 when initialized and the parallel
    // algorithm is called from thread with fp0, fp1 will be here for all iterations on any
    // Intel TBB worker  thread since task group context (with captured fp1) is specified for this
    // parallel algorithm.
}, ctx );

Пример 7 не особенно интересен, поскольку можно добиться такого же результата, если указать fp1 до инициализации планировщика задач. Рассмотрим гипотетическую проблему, когда для двух частей вычисления требуются разные параметры. Эту проблему можно решить так:

Пример #8. Задание параметров вычислений с плавающей запятой для разных частей вычислений.

// Suppose fp0 is used here.
// The task scheduler will capture fp0.
task_scheduler_init tbb_scope;
tbb::task_group_context ctx;
set_fp_settings( fp1 );
ctx.capture_fp_settings();
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // In spite of the fact that floating-point settings are fp1 on the main thread, fp0 will be
    // here for all iterations on any Intel TBB worker thread since the task scheduler captured fp0
    // when initialized.
} );
// fp1 will be used here since TBB algorithms do not change floating-point settings which were set
// before calling.
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // fp1 will be here since the task group context with captured fp1 is specified for this
    // parallel algorithm.
}, ctx );
// fp1 will be used here.

Я уже продемонстрировал одно свойство подхода на основе контекста группы задач в примерах 7 и 8: заданные таким способом параметры имеют более высокий приоритет, чем параметры, заданные с помощью планировщика задач, когда контекст указывается для параллельного алгоритма Intel TBB. При этом подходе наследуется еще одно свойство: вложенные параллельные алгоритмы наследуют параметры вычислений с плавающей запятой из контекста группы задач, указанного для внешнего параллельного алгоритма.

Пример #9. Вложенные параллельные алгоритмы.

// Suppose fp0 is used.
// The task scheduler will capture fp0.
task_scheduler_init tbb_scope;
tbb::task_group_context ctx;
set_fp_settings( fp1 );
ctx.capture_fp_settings();
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // fp1 will be here
    tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
        // Although the task group context is not specified for the nested parallel algorithm and
        // the task scheduler has captured fp0, fp1 will be here.
    }, ctx );
} );
// fp1 will be used here.

Если нужно использовать планировщик задач внутри вложенного алгоритма, можно использовать контекст изолированной группы задач:

Пример #10. Вложенный параллельный алгоритм с изолированным контекстом группы задач.

// Suppose fp0 is used.
// The task scheduler will capture fp0.
task_scheduler_init tbb_scope;
tbb::task_group_context ctx;
set_fp_settings( fp1 );
ctx.capture_fp_settings();
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // fp1 will be used here.
    tbb::task_group_context ctx2( tbb::task_group_context::isolated );
    tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
        // ctx2 is an isolated task group context so it will have fp0 inherited from the task
        // scheduler. That’s why fp0 will be used here.
    }, ctx2 );
}, ctx );
// fp1 will be used here.

В одном блоге невозможно продемонстрировать все возможности поддержки вычислений с плавающей запятой в Intel TBB. Но приведенные примеры демонстрируют основные идеи управления параметрами таких вычислений в Intel TBB для применения в реальных приложениях.

Основные принципы параметров вычислений с плавающей запятой можно объединить в следующий список:

Эти параметры можно задать для всех параллельных алгоритмов Intel TBB с помощью планировщика задач или для отдельных алгоритмов Intel TBB с помощью контекста группы задач;
Параметры, полученные контекстом группы задач, имеют приоритет над параметрами, полученными при инициализации планировщика задач;
По умолчанию все вложенные алгоритмы наследуют такие параметры с внешнего уровня, если не указан ни контекст группы задач с полученными параметрами, ни изолированный контекст группы задач;
При вызове параллельного алгоритма Intel TBB параметры вычислений с плавающей запятой вызывающего потока не изменяются, даже если алгоритм выполняется с другими параметрами;
Параметры, заданные после инициализации планировщика задач, недоступны для параллельных алгоритмов Intel TBB, если не используется подход с контекстом группы задач или не выполняется повторная инициализация планировщика задач;
Пользовательский код в задаче не должен менять эти параметры либо должен восстанавливать прежние параметры до окончания задачи.

P.S. Отложенный планировщик задач получает параметры с плавающей запятой при вызове метода инициализации.

Пример #11: Явная инициализация планировщика задач.

set_fp_settings( fp0 );
tbb::task_scheduler_init tbb_scope( task_scheduler_init::deferred );
set_fp_settings( fp1 );
init.initialize();
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    // The task scheduler is declared when fp0 is set but it will capture fp1 since it is
    // initialized when fp1 is set.
} );
// fp1 will used be here.

P.P.S. Будьте осторожны, если вы используете функцию автоматической записи в планировщике задач. Она не будет работать, если вызов вашей функции осуществляется внутри другого параллельного алгоритма Intel TBB.

Пример #12. Еще одно предупреждение: берегитесь библиотечных функций.

Фрагмент кода 1. Слегка измененный пример 1. Это работоспособный код, здесь нет ошибок.

set_fp_settings( fp0 );
// Run with the hope that Intel TBB parallel algorithm will create a default task scheduler which
// will also capture floating-point settings when initialized.
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {...} );

Фрагмент кода 2. Достаточно вызвать фрагмент кода 1 как библиотечную функцию.

set_fp_settings( fp1 );
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> & ) {
    call “code snippet 1”;
}
// Possibly, you will want to have fp1 here but see the second bullet below.

Этот пример выглядит вполне безобидным, поскольку фрагмент кода 1 задаст нужные параметры и будет выполнять вычисления с fp0. Но в этом примере есть две проблемы:

К моменту вызова фрагмента кода 1 планировщик задач уже будет инициализирован и уже получит fp1. Поэтому фрагмент кода 1 будет выполнять вычисления с fp1, не учитывая параметры fp0;
Изоляция пользовательских параметров вычислений с плавающей запятой нарушается, поскольку фрагмент кода 1 изменяет эти параметры внутри задачи Intel TBB, но не восстанавливает первоначальные параметры. Поэтому нет никаких гарантий относительно параметров вычислений с плавающей запятой после выполнения параллельного алгоритма Intel TBB во фрагменте кода 2.

Фрагмент кода 3. Исправленное решение.

Исправим фрагмент кода 1:

// Capture the incoming fp settings.
get_fp_settings( fpx );
set_fp_settings( fp0 );
tbb::task_group_context ctx;
ctx.capture_fp_settings();
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> &r ) {
    // Here fp0 will be used for all iterations on any Intel TBB worker thread.
}, ctx );
// Restore fp settings captured before setting fp0.
set_fp_settings( fpx );

Фрагмент кода 2 остается неизменным.

set_fp_settings( fp1 );
tbb::parallel_for( tbb::blocked_range<int>( 1, 10 ), []( const tbb::blocked_range<int> &r ) {
    call “fixed code snip 1”.
} );
// fp1 will be used here since the “fixed code snippet 1” does not change the floating-point
// settings visible to “code snippet 2”.

tbb

floating-point

FPU

floating-point settings

Intel® Threading Building Blocks

Istruzione

Open source

Elaborazione parallela

Area tema:

IDZone

↧

HTML5 Hybrid Apps with Admob* Cordova* plug-in

September 28, 2014, 11:34 pm

Latest and popular articles on Intel Technologies

≫ Next: Touch Notifier Node.js IoT & HTML5 Companion App

≪ Previous: Управление режимами вычислений с плавающей запятой при использовании Intel® Threading Building Blocks

The source code for these samples can be found here: https://github.com/gomobile/sample-url-app,https://github.com/gomobile/sample-live-video-streams, https://github.com/gomobile/sample-audio-player or download the Intel® XDK to check out all of the HTML5 samples and templates.

Introduction

Intel XDK® is a HTML5 hybrid application development environment that allow users to develop, debug, test on-device and build projects for various mobile platforms. Along with development features, this development environment provides various HTML5 templates and samples intended for running on various mobile devices and platforms. For more information on getting started, go to https://software.intel.com/en-us/html5/xdkdocs.

Purpose

Amongst developing HTML5 hybrid applications for various mobile platforms using Intel XDK Build system with the intent to distribute as a paid app alone, these applications can also be integrated with ads such as AdMob* banner and interstitial ads which also generate revenues for the respective app developer. By leveraging the Apache Cordova* plug-ins, you can develop compelling HTML5 hybrid apps for any platform and use case. Apache Cordova is a set of device APIs that allow a mobile app developer to access native device function such as the camera or accelerometer from JavaScript. Besides the standard APIs, various plug-ins are available in the Apache Cordova Plug-ins Registry and located across the web on github. For example, the com.google.admob Cordova plug-in provides the capability to initiate Banner and Interstitial ads as well as handle admob ad events.

Design Considerations

The URL/iFrame, Live Video Streams and Audio Player App are designed using Intel XDK App Designer tool under the Develop Tab. All of those sample applications also uses the com.google.admob Cordova plug-in for displaying ads on screen. An Google/AdMob account is required to obtain an ad unit id for displaying banner or interstitial ads on the desired platform.

Creating AdMob Ad Unit ID

Login to https://apps.admob.com
Navigate to the Monetize panel
Click the Monetize new app button
Input your App name, and desired mobile Platform
Select ad format and name ad unit
Review setup instructions

Intel XDK url app screenshot_9-30

The URL/iFrame App is a simple application that displays within your application using an iframe. iFrames within mobile apps are widely used in various mobile app stores for directing traffic to mobile optimized sites as well as utilized the already in place infrastructures.

Intel XDK Live Video Streams screenshot_9-30

The Live Video Streams app is a simple multi-page application that uses Intel App Framework UI JavaScript Library and iframes to display online video streams of live content from various source.

Intel XDK audio player app screenshot_9-30

The Audio Player App demonstrates how to play audio files local to the HTML5 project, online podcast, online .m3u playlist and files on device.

Note: Intel XDK only supports playing *.wav files in the Emulator under the Emulate tab.

Development /Testing

Due to the limited mobile platforms supported by the com.google.admob Cordova plug-in, these sample applications have been tested on iOS and Android devices.

Google Admob Cordova Plug-in Code Snippet

/*
    Function: onDocLoad()
    Parameter: none
    Description: show the Banner Ad [initBanner(...) then showBanner(...)] or interstitial Ad [initInterstitial(...) then cacheInterstitial() then showInterstitial()];
*/
function onDocLoad() {
    //show Banner ad
    //admobAd.initBanner(admob_banner_key, admobAd.AD_SIZE.BANNER.width, admobAd.AD_SIZE.BANNER.height);//create admob banner
    //admobAd.showBanner(admobAd.AD_POSITION.BOTTOM_CENTER);

    //show Interstitial ad
    admobAd.initInterstitial(admob_interstitial_key);//create Interstitial ad
    //admobAd.cacheInterstitial();// load admob Interstitial
    document.addEventListener(admobAd.AdEvent.onInterstitialReceive, onInterstitialReceive, false);
    document.addEventListener(admobAd.AdEvent.onInterstitialFailedReceive, onReceiveFail, false);

    admobAd.cacheInterstitial();// load admob Interstitial
}

Note: You can download the entire source for the plugin at http://sourceforge.net/projects/phonegap-admob/.

↧

Touch Notifier Node.js IoT & HTML5 Companion App

September 28, 2014, 11:47 pm

Latest and popular articles on Intel Technologies

≫ Next: Local Temperature Node.js IoT & HTML5 Companion App

≪ Previous: HTML5 Hybrid Apps with Admob* Cordova* plug-in

The source code for these templates can be found here: https://github.com/gomobile/iotapp-touch-notifier or download the Intel® XDK IoT Edition to check out all the node.js IoT application templates and samples plus HTML5 companion apps.

IoT Projects Panel September 2014

Introduction

IoT Touch and Buzzer Setup September 2014

Intel XDK® IoT Edition is a HTML5 hybrid and node.js application development environment that allow users to deploy, run, debug on various IoT platforms such as the Intel® Galileo and Edison board running the IoT Development Kit Linux Image and utilizes the Grover Starter Kit Plus – IoT Intel® Edition. With the starter kit and Linux* image installed, your development platform is ready to connect to XDK IoT Editon and run your node.js applications. Along with development features, this development environment provides various node.js templates and samples intended for running on Intel IoT platforms. For more information on getting started, go to https://software.intel.com/en-us/html5/documentation/getting-started-with-intel-xdk-iot-edition.

Purpose

IoT Projects Panel September 2014

The Touch Notifier Node.js sample application distributed within Intel® XDK IoT Edition under the IoT with Node.js Projects project creation option showcases how to read digital data from a Grover Starter Kit Plus – IoT Intel® Edition Touch Sensor, start a web server and communicate wirelessly using WebSockets. Along with the use of a touch sensor, a buzzer is used to alert the user engaging with the touch sensor that their invasive actions are received. In order to communicate with sensors, this sample uses the MRAA Sensor Communication Library. The intent of this library is to make it easier for developers and sensor manufacturers to map their sensors & actuators on top of supported hardware and to allow control of low level communication protocol by high level languages & constructs.

Touch Notifier HTML5 Projects Panel September 2014

The Touch Sensor sample HTML5 companion application is also distributed under the Work with a Demo project creation option. This application communicates with the node.js IoT application using WebSockets API and notifies the mobile user that the Touch Sensor is being touched.

Design Considerations

This sample requires the mraa library and xdk daemon to be installed on your board. These two requirements are included in the IoT Development Kit Linux Image which enables communication between your board and XDK IoT Edition plus access to the IO pins. An active connection to your local network using an Ethernet cable or Wireless card such as the Intel 135N PCI Express WiFi/Bluetooth card is required for the WebSockets communication between the board and mobile device. The node.js application reads data from the touch sensor periodically then sends it to the connected (mobile) clients using WebSockets.

[image of node.js application source & development board with sensors connected]

Node.js IoT application

Required npm packages:

express
socket.io

These packages are listed in the package.json file to be built and installed on the connected development board. This is done by clicking the Install/Build button in the bottom toolbar. After installing the node modules, uploading (Click Upload button) and running (Click Run button) this project using Intel XDK IoT Edition will allow for evaluating the communication between the board and mobile application.

Note: You will need to wait for the upload process to complete before running your project.

Web Server

//Create Web Server
var app = require('express')();
var http = require('http').Server(app);
app.get('/', function (req, res) {'use strict';
    res.send('Hello world from Intel Galileo');
});
http.listen(1337, function () {'use strict';
    console.log('listening on *:1337');
});

Digital Read

//Touch Sensor connected to D2 pin
var digital_pin_D2 = new mraa.Gpio(2);
digital_pin_D2.dir(mraa.DIR_IN);

Digital Write

//Buzzer connected to D6
var digital_pin_D6 = new mraa.Gpio(6);
digital_pin_D6.dir(mraa.DIR_OUT);
//Write 0(OFF) to Buzzer connected to Digital IO Pin 6
digital_pin_D6.write(0);

WebSockets

//Create Socket.io object with http server
var io = require('socket.io')(http);
//Attach a 'connection' event handler to the server
io.on('connection', function (socket) {'use strict';
    console.log('a user connected');
    //Emits an event along with a message
    socket.emit('connected', 'Welcome');

    //Start watching Sensors connected to Galileo board
    startSensorWatch(socket);

    //Attach a 'disconnect' event handler to the socket
    socket.on('disconnect', function () {
        console.log('user disconnected');
    });
});

touchnotifierHTML5InputAddr.png September 2014 touchnotifierHTML5InActive.png September 2014 touchnotifierHTML5Active.png September 2014

The HTML5 mobile application requires for that the IP address of your board be inputted to connect to the necessary WebSockets connection for notifying mobile users of Touch sensor activity which is collected by your development board.

HTML5 Companion application

WebSockets

try {
        //Connect to Server
        socket = io.connect("http://" + ip_addr + ":" + port);

        //Attach a 'connected' event handler to the socket
        socket.on("connected", function (message) {
            //Prompt user with Cordova notification alert - Include under Intel XDK Projects Panel
            navigator.notification.alert('Welcome',  // message"",                     // callback'Hi There!',            // title'Ok'                  // buttonName
            );
        });

        //Set all Back button to not show
        $.ui.showBackButton = false;
        //Load page with transition
        $.ui.loadContent("#main", false, false, "fade");

        socket.on("message", function (message) {
            //alert("Is anyone there? "+message);
            if (message === "present") {
                $("#notifier_circle").attr("class", "green");
                //Update log
                $("#feedback_log").append(Date().substr(0, 21) + " Someone is Present!
");
                //Prompt user with Cordova notification alert
                navigator.notification.alert('Someone is Present!',  // message"",                     // callback'Check Your Door',            // title'Ok'                  // buttonName
                );
                //Wait 2 seconds then turn back to gray
                setTimeout(function () {
                    $("#notifier_circle").attr("class", "gray");
                }, 3000);
            }
        });
    } catch (e) {
        navigator.notification.alert("Server Not Available!",  // message"",                     // callback'Connection Error!',            // title'Ok'                  // buttonName
        );
    }

Development /Testing

Each of the templates have been test on Intel® Galileo Generation 1 and 2 boards as well as the Intel® Edison board.

↧

Local Temperature Node.js IoT & HTML5 Companion App

September 28, 2014, 11:57 pm

Latest and popular articles on Intel Technologies

≫ Next: How to model scalability using Intel® Advisor XE 2015

≪ Previous: Touch Notifier Node.js IoT & HTML5 Companion App

The source code for these templates can be found here: https://github.com/gomobile/iotapp-local-temperature or download the Intel® XDK IoT Edition to check out all the node.js IoT application templates and samples plus HTML5 companion apps.

IoT Projects Panel September 2014

Introduction

Temperature Sensor Galileo Setup September 2014

Purpose

Local Temperature IoT Project Panel September 2014

The Local Temperature Node.js sample application distributed within Intel® XDK IoT Edition under the IoT with Node.js Projects project creation option showcases how to read analog data from a Grover Starter Kit Plus – IoT Intel® Edition Temperature Sensor, start a web server and communicate wirelessly using WebSockets. In order to communicate with sensors, this sample uses the MRAA Sensor Communication Library. The intent of this library is to make it easier for developers and sensor manufacturers to map their sensors & actuators on top of supported hardware and to allow control of low level communication protocol by high level languages & constructs.

Local Temperature HTML5 Companion Project Panel September 2014

The Local Temperature sample HTML5 companion application is also distributed under the Work with a Demo project creation option. This application communicates with node.js IoT application using WebSockets API and visualizes the received temperature data in a scatter plot using the D3 JavaScript Library.

Design Considerations

This sample requires the mraa library and xdk daemon to be installed on your board. These two requirements are included in the IoT Development Kit Linux Image which enables communication between your board and XDK IoT Edition plus access to the IO pins. An active connection to your local network using an Ethernet cable or Wireless card such as the Intel 135N PCI Express WiFi/Bluetooth card is required for the WebSockets communication between the board and mobile device. The node.js application reads data from the temperature sensor then converts the value to degrees Fahrenheit. The collected temperature data is sent to the connected (mobile) clients using WebSockets.

[image of node.js application source & development board with sensors connected]

Node.js IoT application

Required npm packages:

express
socket.io

Note: You will need to wait for the upload process to complete before running your project.

Web Server

//Create Web Server
var app = require('express')();
var http = require('http').Server(app);
app.get('/', function (req, res) {'use strict';
    res.send('Hello world from Intel Galileo');
});
http.listen(1337, function () {'use strict';
    console.log('listening on *:1337');
});

Analog Read

var mraa = require("mraa");
//GROVE Kit A0 --> Aio(0)
var myAnalogPin = new mraa.Aio(0);
//Shift Temperature Sensor Value bitwise to the right
var a = myAnalogPin.read() >> 2;

WebSockets

//Create Socket.io object with http server
var io = require('socket.io')(http);
//Attach a 'connection' event handler to the server
io.on('connection', function (socket) {'use strict';
    console.log('a user connected');
    //Emits an event along with a message
    socket.emit('connected', 'Welcome');

    //Start watching Sensors connected to Galileo board
    startSensorWatch(socket);

    //Attach a 'disconnect' event handler to the socket
    socket.on('disconnect', function () {
        console.log('user disconnected');
    });
});

localTempHTML5InputAddr.png September 2014 localTempHTML5Active.png September 2014

The HTML5 mobile application requires for that the IP address of your board be inputted to connect to the necessary WebSockets connection for visualizing the temperature data on your mobile device which was collected by your development board.

HTML5 Companion application

WebSockets

    try {
        //Connect to Server
        socket = io.connect("http://" + ip_addr + ":" + port);

        //Attach a 'connected' event handler to the socket
        socket.on("connected", function (message) {
            //Apache Cordova Notification - Include under the Projects Panel
            navigator.notification.alert("Great Job!",  // message"",                     // callback'You are Connected!',            // title'Ok'                  // buttonName
            );

            //Set all Back button to not show
            $.ui.showBackButton = false;
            //Load page with transition
            $.ui.loadContent("#main", false, false, "fade");
        });

        socket.on("message", function (message) {
            chart_data.push(message);
            plot();
            //Update log
            $("#feedback_log").text("Last Updated at " + Date().substr(0, 21));
        });
    } catch (e) {
        navigator.notification.alert("Server Not Available!",  // message"",                     // callback'Connection Error!',            // title'Ok'                  // buttonName
        );
    }

D3.js Scatter plot

//Scatter plot-Selects the specified DOM element for appending the svg
var chart_svg = d3.select("#chart").append("svg").attr("id", "container1").attr("width", window.innerWidth).attr("height", 0.6 * height).append("g");

chart_svg.attr("transform", "translate(25," + margin.top + ")");

var x1 = d3.scale.linear().domain([0, 5000]).range([0, 100000]);

var y1 = d3.scale.linear().domain([0, 200]).range([0.5 * height, 0]);

//Add X Axis grid lines
chart_svg.selectAll("line.y1")
    .data(y1.ticks(10))
    .enter().append("line")
    .attr("class", "y")
    .attr("x1", 0)
    .attr("x2", 100000)
    .attr("y1", y1)
    .attr("y2", y1)
    .style("stroke", "rgba(8, 16, 115, 0.2)");

//This is for the Scatterplot X axis label
chart_svg.append("text").attr("fill", "red").attr("text-anchor", "end").attr("x", 0.5 * window.innerWidth).attr("y", 0.55 * height).text("Periods");

var x1Axis = d3.svg.axis().scale(x1).orient("top").tickPadding(0).ticks(1000);
var y1Axis = d3.svg.axis().scale(y1).orient("left").tickPadding(0);

chart_svg.append("g").attr("class", "x axis").attr("transform", "translate(0," + y1.range()[0] + ")").call(x1Axis);

chart_svg.append("g").attr("class", "y axis").call(y1Axis);

var dottedline = d3.svg.line().x(function (d, i) {
    'use strict';
    return x1(i);
}).y(function (d, i) {'use strict';
    return y1(d);
});
......

Development /Testing

Each of the templates have been test on Intel® Galileo Generation 1 and 2 boards as well as the Intel® Edison board.

↧

How to model scalability using Intel® Advisor XE 2015

September 30, 2014, 8:00 am

Latest and popular articles on Intel Technologies

≫ Next: How to use the Intel® Energy Profiler in Intel® System Studio 2015

≪ Previous: Local Temperature Node.js IoT & HTML5 Companion App

Introduction

Intel® Advisor XE 2015 now includes some new capabilities for modeling the scalability of your application. This article steps through runtime modeling and data set size modeling, and outlines these new capabilities.

Run your application using the Intel Advisor XE 2015 suitability analysis

First add annotations and rebuild your application in Release mode.
Next bring up the Intel Advisor XE 2015 Workflow by clicking Tools > Advisor XE 2015 > Open Advisor Workflow.
Click the Collect Suitability Data button.

The key observation from the scalability graph is that the application is not scaling well as designed. Intel Advisor XE reports a suggestion that your tasks are too fine-grained.

Model runtime

Intel Advisor XE has several techniques where you can model the runtime and see how the application will perform assuming you modify how the application is applying parallelism.

Check all of the recommend changes.

We can see clear benefits. Notice that in the case of 32 CPUs we go from less than a 1x improvement to over a 4x maximum gain from our parallel region.

But our graph shows that we see the maximum gain when we have 16 CPUs; adding additional resources decreases the performance. There are several possible reasons that this can happen:

There is not enough work to keep all of the CPUs busy.
The work is not balanced on all of the CPUs.
The runtime overhead to keep track of additional threads is too high.
There is lock contention

Model Data Set Size

Intel Advisor XE 2105 now has a way for you to model how your parallel region will perform under different workloads. It allows you to change the size of your data set and modify how long each task iteration takes, thereby testing the scalability without making any code changes. This feature is particularly useful for CPU-bound workloads.

Look at the Loops iteration (Task) Modeling area of the Intel Advisor XE.

Using the two sliders you can increase or decrease the number of tasks, that is, the size of your workload. You can also increase or decrease how long each task takes. Testing your design under different workloads is critical to understanding if you are using the correct design for the amount of work your problem is assigned. Intel Advisor XE lets you increase of decrease the number of tasks in multiples of 5, so 5x, 25x and 125x. You also increase or decrease the duration of tasks in a similar manner.

In our example let’s multiply both the number of tasks and the duration of each task by 25.

You can see below that the algorithm performs differently when run under this new workload.

Not only does the new algorithm scale as we increase the CPU count past 16, we also increase our maximum site gain to 32x from the previous 4x gain for 32 CPUs. In this example the parallel region does not have enough work and each of the tasks is too fine-grained to work efficiently. We have shown that we can achieve good scalability by increasing the data set size and also increasing the amount of work each task performs.

Summary

Intel Advisor XE 2015 is a powerful tool for modeling the scalability of your application. By using runtime modeling and the new features to dynamically change the size of your data set you can see how to tune your algorithm without making any code changes.

Intermedio

Intel Compilers Vectorization Reports Optimization Reports

Sviluppo multithread

Area tema:

IDZone

↧

How to use the Intel® Energy Profiler in Intel® System Studio 2015

October 2, 2014, 6:44 am

Latest and popular articles on Intel Technologies

≫ Next: How to do a system wide analysis using Intel® VTune™ Amplifier for Systems

≪ Previous: How to model scalability using Intel® Advisor XE 2015

Introduction

Intel® System Studio 2015 now contains an energy and power profiler called Intel® Energy Profiler. Using the Intel Energy Profiler allows you to collect sleep state, frequency and temperature data that lets you find the software that is causing unwanted power use. This article provides an overview of the Intel® Energy Profiler.

Background

Two key indicators that effect how much power your system is using are CPU Sleep states and CPU Frequency.

CPU Sleep states (C-States)
- CPU Sleep states indicate during what intervals your CPU is asleep. The main goal of CPU Sleep states is to show when the system is sleeping, what sleep state it was in and what woke up the system. The higher the sleep state the lower the power usage.
CPU Frequency (P-states)
- CPU’s also have the ability to change the core clock frequency, power usage will be higher the greater the frequency.

The following diagram shows how these c-states and p-states inter-relate.

Depending on your Android target you will need to use a different collector:

Silvermont, Haswell systems
- socwatch collector
Clovertrail+
- wuwatch
Other embedded linux* systems.
- amplxe-cl

The remainder of this article will focus on how you can collect C-state and P-state data for your system and visualize this data using Intel® VTune™ Amplifier 2015 for Systems using socwatch.

Socwatch

SoC Watch (aka SoCWatch) is a command line tool for monitoring system behaviors related to power consumption on Intel® architecture-based platforms. It monitors power states, frequencies, wakeups, and various other metrics that provide insight into the system’s energy efficiency.

The following diagram shows how socwatch can be used.

Installation

SoCWatch is currently intended for Android-based systems. See the release notes for detailed system requirements.

It is possible that your Android based system already had the socwatch kernel modules integrated into the system. If this is not the case then see the section marked “Building the kernel module”.

Make sure your host is connected to the target via adb before running the install script.

1. After unzipping the SoCWatch package on your host system, run the socwatch_android_install.sh script on a Linux host or from a Cygwin window on a Windows host. Run the socwatch_android_install.bat file from a Windows host.

socwatch_android_install.sh or socwatch_android_install.bat

The script installs the socwatch executables to the /data/socwatch directory on the target by default. Use the –d option to select a different install directory and the –s option to define a specific Android* device if multiple devices are connected to the host via adb.

2. Using the adb command, start a shell with root privileges.

> adb root

> adb shell

3. Navigate to the directory containing the driver.

> cd /lib/modules

4. Load the driver.

> insmod SOCWATCH1_*.ko

5. Confirm the driver is loaded.

> lsmod

6. When necessary, type rmmod SOCWATCH1_* to unload the driver.

Building the Kernel Module

If the SoCWatch device driver is not pre-installed in the OS image, you will need to build it.

1. Copy the socwatch_android.zip file to the host system used to build the Android* kernel.

2. Extract the contents with the command:

> tar xvzf socwatch_android.zip The socwatch_android directory is created.

3. cd into the socwatch_android/socwatch_driver directory.

4. Execute the build_driver script with the command: > sh ./build_driver –k <kernel-build-dir> where <kernel-build-dir> is replaced with the local Android* lib/modules directory produced while building the Android* kernel. The –k switch is optional and is not required if the DEFAULT_KERNEL_BUILD_DIR value is properly set in the build_driver script.

Collecting data on your system

cd /data/socwatch

. ./setup_socwatch_env.sh

To collect c-state and p-state data on your system run the following socwtach command.

>./socwatch –-max-detail –f cpu-cstate –f cpu-pstate –t 60 –o ./results/test

This command will run for 60 seconds and create a files called test.sw1 and test.csv located in results directory.

To view the colelcted data you need to copy the files back to your host system using adb.

> adb pull /data/socwatch/results/test.csv c:\results

> adb pull /data/socwatch/results/test.sw1 c:\results

To import these files into VTune Amplfier 2015 for Systems run the following commands, from the windows prompt:

First run the amplxe-vars.bat file in the VTune Amplifier install directory.
Run amplxe-cl.exe -import test.sw1 C:\results\test

This will create a results directory called test in C:\results. You can open this result directory using the following command:

amplxe-gui.exe C:\results\test

Frequency summary:

Sleep state summary:

Area tema:

IDZone

↧

How to do a system wide analysis using Intel® VTune™ Amplifier for Systems

October 2, 2014, 8:07 am

Latest and popular articles on Intel Technologies

≫ Next: Adding AdMob* by Google* to Your Cordova* Application

≪ Previous: How to use the Intel® Energy Profiler in Intel® System Studio 2015

Introduction

Intel® System Studio is Intel’s suite of software tools for embedded processors and contains features that allow you to profile your entire system and not just the individual cores. This article will describe a new method of profiling your system on an embedded target.

Background

There are several techniques you can use to profile your system. This article uses the command line version of VTune™ Amplifier for Systems known as amplxe-cl. The amplxe-cl program now contains the option to specify a remote target. To profile your system you need to specify the proper analysis type, this article will analyze the memory bandwidh on a system.

We will be using the Intel processor, code named Sandy Bridge. The command for profiling your system is as follows:

amplxe-cl –target ssh:root@ip_addr –collect snb-bandwith -d 5 --search-dir bin:p=<local directory containing modules>

-target ssh:root@ip_addr
- This specifies that this will be a remote collection over ssh to the system running at internet address ip_addr.
-collect snb-bandwidth
- This specifies that we will be collecting memory bandwidth on an Intel target, code named Sandy Bridge.
-d 5
- This specified the collection will run for 5 seconds.
--search-dir bin:p=<local directory containing modules>
- For system-wide collection, a lot of modules running in the system during the colelction are copied from the target to the host, which may take a while. However, this only happens once since amplxe-cl caches the target system modules on the host for faster access during the next collection. If you do not want the command to take the modules from the device you can specify a local directory on the host to be searched first as above. See the VTune Amplifier for Systems help for more information.

VTune Amplifier 2014 for Systems will create a result directory containing the data you collected. To view the data you would use the command:

amplxe-gui r001bw

(where r001bw is the actual directory containing your results)

Using the Bandwidth View inside of VTune Amplifier for Systems you can see the Read and Write bandwidth expressed in Gbytes per second.

You can also view the PMU (core) and Uncore based events by using the Hardware Events Count view but you will need to view the PMU counters separately from the Uncore counters:

PMU View:

Uncore View:

Summary

VTune Amplifier for Systems contains some powerful new features for profiling your system. Using these remote capabilties, together with the predefined analysis types you can easily collect and view your profiling data and solve the most difficult performance bottlenecks.

Area tema:

IDZone

↧

Adding AdMob* by Google* to Your Cordova* Application

October 2, 2014, 9:49 am

Latest and popular articles on Intel Technologies

≫ Next: Using the Dolby API in the Intel XDK

≪ Previous: How to do a system wide analysis using Intel® VTune™ Amplifier for Systems

If you want to include AdMob* (by Google*) advertisements as part of your HTML5 hybrid mobile app, you will need to use a Cordova plugin. Unlike the desktop browser solution, mobile apps require a native code component to retrieve and display ads on mobile devices. Not all mobile ad services have this restriction, but if you want to serve AdMob advertisements in your app you will have to use a Cordova plugin.

Intel does not endorse any specific advertising plugin for use with the Intel XDK! Be aware that some advertising plugins have fees or revenue sharing features built into them. We cannot guarantee which plugins are the best or most appropriate for use with your application.

There are a variety of Cordova plugins available for serving ads; some serve ads from third-party sources, a few serve ads from the AdMob network. You are not required to use AdMob to serve ads, but only the use of AdMob plugins are described in this article. Plugins for ad services can be located by doing a general search of the web for "mobile ad services."

AdMob plugins for Cordova can be found by searching the Cordova Plugins Registry or PlugReg (an independent Cordova plugin registry). Details regarding how to use the AdMob system as a means of monetization are available in the AdMob support pages.

Before you can serve any AdMob ads you must sign up for an AdMob account at www.admob.com. AdMob does not charge a fee for creating an account or for serving up AdMob ads (be aware that some AdMob plugins vendors do charge a fee for the use of their plugin). If you have an AdMob account you must create a set of Ad Unit IDs that identify your ad impressions and provide these IDs as part of the AdMob API initialization sequence within your app. A screenshot of the online AdMob tool you use to create the Ad Unit IDs is shown below.

IMPORTANT: each application should have its own set of Ad Unit IDs! If you do not yet have an app in an app store, you can use the "manual" method to identify your app for the purpose of obtaining Ad Unit IDs.

To see the latest available samples provided with the Intel XDK it is best to check the "Work with a Demo" option under the "Start a New Project" button. In addition to those samples provided on the Intel XDK "Work with a Demo" panel, a few additional examples are listed below; they may use different AdMob plugins (from different authors):

The article titled HTML5 Hybrid Apps with Admob* Cordova* Plugins provides details for several of the AdMob examples available in the Intel XDK.

NOTE: because an AdMob application includes a third-party Cordova plugin, it will only run on a real device. You must use the Build tab to create an APK (for Android) or IPA (for iOS) to test your AdMob application. If you attempt to run this app using the Emulate, Test or Debug tabs the AdMob APIs will fail. Apps that utilize Cordova plugins can only be built using the Cordova build targets. Attempting to use the "legacy" build targets will not work.

↧

Using the Dolby API in the Intel XDK

October 2, 2014, 11:30 am

Latest and popular articles on Intel Technologies

≫ Next: Diagnostic 15304: non-vectorizable loop instance

≪ Previous: Adding AdMob* by Google* to Your Cordova* Application

When I think of Dolby technology, I usually think of movie theaters and high end stereos, adding life to soundtracks and music. It turns out that they've also been working on bringing some of that clever technology to hand-held devices. This technology is designed to enhance different sorts of audio, including games, movies and music. This is cool if you own one of these devices and can experience better audio, but it's also interesting to developers.

As an app developer, you want to be able to take advantage of this technology to maximum effect. If you're designing a game, you want to enhance it by ensuring that the Dolby game profile is active. If you're playing music or video, you'll want to activate the appropriate profile. Fortunately the Dolby Cordova Plugin makes that easy.

The dolby API consists of three parts:

dolby.dap - contains various functions you'll want to call, like initialize and setProfile
dolby.DapProfile - contains the available profiles (GAME, MUSIC, VOICE and MOVIE)
dolby.DapError - various error codes, provided as parameters to onFail callbacks

If all you want to do is enable Dolby functionality, that's easy. The API relies on a Cordova Plugin which is available as a featured plugin in the Intel XDK. To access it, just go to the projects page, expand the "Plugins And Permissions" pane and check "Dolby Audio API". This will cause the plugin to be loaded in your app, exposed as a global variable dolby. For example, if you want to enable the feature for your game, you just need to add this to your initialization code:

var onDsConnected = function() {
    console.log("Dolby started successfully");
};
var onFail = function(err) {
    console.log("Dolby failed due to ", err);
};
dolby.dap.initialize(dolby.DapProfile.GAME, onDsConnected, onFail);

Now, if all you care about is enabling it, this will be fine. But you probably want something more sophisticated, say if you want to switch to the music profile for interstitial music while loading a new level:

dolby.setProfile(dolby.DapProfile.Music);

Aside from initializing and setting profiles, there are a few other convenient capabilities. Suppose you've got things set up for your App, with the profile set for your wicked action packed game, but then the user gets a phone call. The user, no doubt saavy about these things, has his phone set to use the VOICE profile, the better to hear his phone conversations. You don't want to mess with that, so when the game is interrupted, you want to defer to whatever the system setting is, and then go back to the GAME profile when it resumes. The Dolby API allows for that with the suspendSession() and restartSession() functions:

onPause = function () {
    dolby.dap.suspendSession();
};
document.addEventListener("pause", onPause, false);


onResume = function () {
    var success = function () {
        console.log("Resuming OK");
    }
    var err = function () {
        console.log("Problem resuming");
    }

    dolby.dap.restartSession(success, err);
};
document.addEventListener("resume", onResume, false);

There are a couple other functions, like getSelectedProfile() to check the current setting, and release() to release control and go back to the system settings. All the details can be found in the documentation available at the github site - https://github.com/DolbyDev/Dolby-Audio-Plugin-for-Cordova or at Dolby's developer site - http://developer.dolby.com. I've also got a working demo app at https://github.com/oldgeeksguide/dolby-cordova-plugin-example that you can grab and import into the Intel XDK.

And if you get a chance to try a device with this capability, check it out. It makes the builtin speakers sound better, and works great with headphones!

↧

Diagnostic 15304: non-vectorizable loop instance

October 2, 2014, 1:45 pm

Latest and popular articles on Intel Technologies

≫ Next: Diagnostic 15331: Using FP model: precise prevents vectorization

≪ Previous: Using the Dolby API in the Intel XDK

Product Version: Intel(R) Visual Fortran Compiler XE 15.0.0.070

Cause:

The vectorization report generated using Visual Fortran Compiler's optimization and vectorization report options (-Qvec-report2 -O2) includes non-vectorized loop instance when using the following compiler option (Win OS): -assume:dummy_aliases

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n)
  implicit none
  real, intent(inout) :: a(n)
  real, intent(in)    :: b(n)
  integer, intent(in) :: n
  integer :: i

  do i=1,n
         a(i) = b(i)+1
  end do

end subroutine foo

Report from: Vector & Auto-parallelization optimizations [vec, par]

LOOP BEGIN at f15304.f90(8,3)
<Multiversioned v2>
remark #15304: loop was not vectorized: non-vectorizable loop instance from multiversioning
LOOP END

Resolution:

Using compiler option -assume:nodummy_aliases ( in Linux OS and OS X: -assume nodummy_aliases) will improve performance and get this loop to vectorize, however care should be taken to ensure that programs compiled with -assume:nodummy _aliasesoutput correct results.

Back to the list of vectorization diagnostics for Intel Fortran

remark

vectorization

compiler

Fortran

Intel® Integrated Native Developer Experience (INDE)

Compilatori

Intel® Composer XE

Intel® Cluster Studio XE

Ottimizzazione

Elaborazione parallela

Vettorizzazione

Esempio di codice

Controllo degli errori

Area tema:

IDZone

Intel Compilers Vectorization Reports Optimization Reports

↧

Diagnostic 15331: Using FP model: precise prevents vectorization

October 2, 2014, 4:04 pm

Latest and popular articles on Intel Technologies

≫ Next: Diagnostic 15319: Using NOVECTOR directive

≪ Previous: Diagnostic 15304: non-vectorizable loop instance

Product Version: Intel(R) Visual Fortran Compiler XE 15.0.0.070

Cause:

When using Intel Fortran Compiler's option -fp:precise (Linux OS and OS X syntax: -fp-model precise) the vectorization report generated using Visual Fortran Compiler's optimization and vectorization report options ( -O2 - Qvec-report2 - Qopt-report:2) includes non-vectorized loop instance.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n)
	implicit none
    integer, intent(in) :: n
	real, intent(inout) :: a(n)
	real, intent(out) :: b
	real :: x = 0
	integer :: i

	do i=1,n
			x = x + a(i)
	end do

	b = x

end subroutine foo

Report from: Vector & Auto-parallelization optimizations [vec, par]

LOOP BEGIN at f15331.f90(9,2)

remark #15331: loop was not vectorized: precise FP model implied by the command line or a directive prevents vectorization. Consider using fast FP model

LOOP END

Resolution:

Using fast FP model (Win: -fp:fast , Linux and OS X syntax: -fp-model fast) option which allows more aggressive optimizations on floating-point data will get this loop vectorized.

Back to the list of vectorization diagnostics for Intel Fortran

remark

vectorization

Intel® Cluster Studio XE

Intel® Media Server Studio Professional Edition

Floating-point Optimizations

URL:

fp-model, fp

Area tema:

IDZone

↧

Diagnostic 15319: Using NOVECTOR directive

October 2, 2014, 5:37 pm

Latest and popular articles on Intel Technologies

≫ Next: Diagnostic 15335: Vectorization possible but seems inefficient

≪ Previous: Diagnostic 15331: Using FP model: precise prevents vectorization

Product Version: Intel(R) Visual Fortran Compiler XE 15.0.0.070

Cause:

When using NOVECTOR directive in code, the vectorization report generated using Visual Fortran Compiler's optimization and vectorization report options ( -O2 -Qopt-report:2) includes non-vectorized loop instance.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n)
	implicit none
	integer, intent(in) :: n
	real, intent(inout) :: a(n)
	real, intent(in)    :: b(n)

    integer :: i

!DEC$ NOVECTOR

       do i=1,n
		     a(i)= b(i)+1
       end do

end subroutine foo

Report from: Vector & Auto-parallelization optimizations [vec, par]

LOOP BEGIN at f15319.f90(11,8)

remark #15319: loop was not vectorized: novector directive used

LOOP END

Resolution:

There may be cases where you want to explicitly avoid vectorization of a loop; for example, if vectorization would result in a performance regression rather than an improvement. In these cases, you can use the NOVECTOR directive to disable vectorization of the loop.

Back to the list of vectorization diagnostics for Intel Fortran

Intel Compilers Vectorization Reports Optimization Reports

Intel® Integrated Native Developer Experience (INDE)

Intel® Composer XE

Controllo degli errori

Area tema:

IDZone

Intel Compilers Vectorization Reports Optimization Reports

↧

Diagnostic 15335: Vectorization possible but seems inefficient

October 3, 2014, 8:47 am

Latest and popular articles on Intel Technologies

≫ Next: Diagnostic 15344: Loop was not vectorized: vector dependence prevents vectorization

≪ Previous: Diagnostic 15319: Using NOVECTOR directive

Product Version: Intel(R) Visual Fortran Compiler XE 15.0.0.070

Cause:

The vectorization report generated using Visual Fortran Compiler's optimization and vectorization report options -O2 -Qvec-report2 -Qopt-report:2 states that loop was not vectorized: vectorization possible but seems inefficient.

Example:

An example below will generate the following remark in optimization report:

subroutine foo(a, b, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real, intent(out)   :: b
    real :: x = 0
    integer :: i

    do i=1,n
            x = x + a(2*i)
    end do

    b = x

end subroutine foo

Report from: Vector optimizations [vec]

LOOP BEGIN at f15335.f90(9,5)

remark #15335: loop was not vectorized: vectorization possible but seems inefficient. Use vector always directive or /Qvec-threshold0 to override
LOOP END

Resolution:

Using !DEC$ VECTOR ALWAYS directive in the code will vectorize the loop by overriding efficiency heuristics of the vectorizer.

Back to the list of vectorization diagnostics for Intel Fortran

Intel® Integrated Native Developer Experience (INDE)

Intel® Integrated Native Developer Experience Build Edition per OS X*

Ottimizzazione

Vettorizzazione

Area tema:

IDZone

Intel Compilers Vectorization Reports Optimization Reports

↧

Diagnostic 15344: Loop was not vectorized: vector dependence prevents vectorization

October 3, 2014, 9:34 am

Latest and popular articles on Intel Technologies

≫ Next: Diagnostic 15414: Loop was not vectorized: loop body became empty after optimizations

≪ Previous: Diagnostic 15335: Vectorization possible but seems inefficient

Product Version: Intel(R) Visual Fortran Compiler XE 15.0.0.070

Cause:

When using Intel Visual Fortran Compiler's optimization and vectorization report options -O2 -Qvec-report2 -Qopt-report:2 the vectorization report generated states that loop was not vectorized since vector dependence prevents vectorization.

Example:

An example below will generate the following remark in optimization report:

integer function foo(a, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real :: max
    integer :: inx, i

    max = a(0)
    do i=1,n
        if (max < a(i)) then
            max = a(i)
            inx = i*i
        endif
    end do

    foo = inx

end function

Report from: Vector optimizations [vec]

LOOP BEGIN at f15344.f90(9,5)
remark #15344: loop was not vectorized: vector dependence prevents vectorization. First dependence is shown below. Use level 5 report for details [ f15344.f90(12,13) ]
remark #15346: vector dependence: assumed ANTI dependence between line 10 and line 10 [ f15344.f90(12,13) ]
LOOP END

Resolution:

Rewriting the code as in the following example will resolve vector dependence and the loop will be vectorized

integer function foo(a, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a(n)
    real :: max
    integer :: inx, i

    max = a(0)
    do i=1,n
        if (max < a(i)) then
            max = a(i)
            inx = i
        endif
    end do

    foo = inx*inx

end function

Back to the list of vectorization diagnostics for Intel Fortran

Intel® Integrated Native Developer Experience (INDE)

Intel® Integrated Native Developer Experience Build Edition per OS X*

Area tema:

IDZone

Intel Compilers Vectorization Reports Optimization Reports

↧

Diagnostic 15414: Loop was not vectorized: loop body became empty after optimizations

October 3, 2014, 12:44 pm

Latest and popular articles on Intel Technologies

≫ Next: Intel® XDK "Cordova for Android" Build Options

≪ Previous: Diagnostic 15344: Loop was not vectorized: vector dependence prevents vectorization

Product Version: Intel(R) Visual Fortran Compiler XE 15.0.0.070

Cause:

The vectorization report generated when using Visual Fortran Compiler's optimization options (-O2 -Qopt-report:2) states that loop was not vectorized since loop body became empty after optimizations.

Example:

An example below will generate the following remark in optimization report:

integer function foo(a, b, n)
    implicit none
    integer, intent(in) :: n
    real, intent(inout) :: a
    real, intent (in)   :: b
    integer :: i

    do i=1,n
           a = b + 1
    end do

    foo = a

end function

Report from: Vector optimizations [vec]

LOOP BEGIN at f15414.f90(8,5)
remark #15414: loop was not vectorized: nothing to vectorize since loop body became empty after optimizations
LOOP END

Resolution:

In the example above, there is only one expression inside the loop. When moved outside the loop as a result of the compiler's optimization process there is nothing else left inside the loop to vectorize.

Back to the list of vectorization diagnostics for Intel Fortran

Intel® Integrated Native Developer Experience (INDE)

Intel® Integrated Native Developer Experience Build Edition per OS X*

Elaborazione parallela

Vettorizzazione

Area tema:

IDZone