Arquivo da categoria: desenvolvimento

Instalação do Intel Xeon Phi no CentOS 7

Este documento detalha a instalação dos pacotes de software necessários para o funcionamento do Intel Xeon Phi (MPSS 3.6.1) no CentOS Linux release 7.2.1511 (Core) com kernel 3.10.0-327.el7.x86_64. Importante observar que a versão do kernel deve ser compatível. Caso não esteja de acordo com a documentação do MPSS, deve-se instalar os pacotes do kernel adequado. Veja mais em: http://registrationcenter.intel.com/irc_nas/8495/mpss_users_guide.pdf

0. Desabilitar o NetworkManager

Por padrão, o NetworkManager vem habilitado no CentOS. Devemos desabilitá-lo :

# chkconfig NetworkManager off
# chkconfig network on
# service NetworkManager stop
# service network start

1. Download dos Pacotes

Baixar o arquivo mpss-3.6.1-linux.tar do site https://software.intel.com/en-us/articles/intel-manycore-platform-software-stack-mpss:

# mkdir /root/mic
# cd /root/mic
# wget http://registrationcenter.intel.com/irc_nas/8495/mpss-3.6.1-linux.tar
# tar xvf mpss-3.6.1-linux.tar

2. Instalar os pacotes

Primeiro passo desta fase, verificar que não existe uma versão anterior instalada:

# rpm -qa | grep -e intel-mic -e mpss

Esse comando não deve retornar nenhum valor. Em seguida, devemos instalar os pacotes base:

# cd /root/mic/mpss-3.6.1
# cp ./modules/`uname -r`.rpm
# yum install *.rpm

Caso encontre algum problema de incompabilidade no kernel, por exemplo não encontrar na pasta /root/mic/mpss-3.6.1/modules os pacotes equivalentes a sua versão, faça o seguinte:

# yum install kernel-headers kernel-devel
# cd /root/mic/mpss-3.6.1/src
# rpmbuild –rebuild mpss-modules.src.rpm
# yum install /root/rpmbuild/RPMS/x86_64/
.rpm

Os passos anteriores podem ser feitos a cada atualização do kernel. Mas talvez seja melhor não atualizar os pacotes do kernel.

Por último, carregue o módulo do kernel da mic:

# modprobe mic

Demora alguns segundos. Se nada retornar, então deu tudo certo. Vamos chegar o status da mic:

# micctrl -s
# mic0: ready

Devemos atualizar a memória flash do dispositivo:

# micflash -update -device all
No image path specified – Searching: /usr/share/mpss/flash
mic0: Flash image: /usr/share/mpss/flash/EXT_HP2_C0_0391-02.rom.smc
mic0: Flash update started
mic0: Flash update done
mic0: SMC update started
mic0: SMC update done
mic0: Transitioning to ready state
Please restart host for flash changes to take effect

3. Aplicar as configurações default

Inicializar as configurações default:

# micctrl –initdefaults

Verificar se o serviço mpss pode ser inicializado:

# service mpss start

Habilitar para inicializar junto com o sistema:

# chkconfig mpss on

Verificar se é possível entrar no mic através do SSH (você precisa ter criado a chave do root antes):

# ssh mic0

Executar dois comandos que verificam o status da mic:

# miccheck

# micinfo

4. Adicionar um usuário

Primeiro, adicione o usuário no host:

# adduser usuario

# passwd usuario

Em seguida logue como o usuário e crie uma chave SSH:

\$ ssh-keygen

De volta ao root, adicione o usuário ao mic:

# micctrl –useradd=usuario

Pronto! Agora o usuário pode logar no mic.

Uma pequena comparação entre o Generics do Java e do C#

Meu objetivo neste post é comparar uma característica do Generics do Java e do C# que encontrei quando tentei criar uma classe para representar uma matriz. Queria guardar a matriz em um vetor linear e acessar seus elementos fazendo uma pequena aritmética no número de linhas e colunas. O objetivo era parametrizar a classe para que pudesse criar matrizes para qualquer tipo numérico.

Comecei pelo Java e tentei o seguinte código:

package matrix;

public class Matrix <T extends Number> {

	private int rows;
	private int columns;
	private T[] linearArray;
	
	public int rows() { return rows;}
	public int columns() { return columns;}
	
	public Matrix  (int rows, int cols){
		this.rows = rows;
		this.columns = cols;
		linearArray = new T[rows*columns];
	}
	
	public T get(int i, int j) {
		if (i > rows || j > columns)
			return null;
		int localIndex = i * rows + j;
		return linearArray[localIndex];
	}
	
	public void set(int i, int j, T value) {
		if (i > rows || j > columns)
			return;
		int localIndex = i * rows + j;
		linearArray[localIndex] = value;
	}
}

O problema é que esta linha:

linearArray = new T[rows*columns];

Fornece o seguinte erro:

Cannot create a generic array of T	Matrix.java	/MatrixComponents/src/matrix	line 15	Java Problem

Pela descrição, é um problema do Java. Criei então código semelhante em C#:

using System;

namespace TestandoArraysGenerics
{
	public class Matrix <T>
	{
		T[] elements;
		int rows;
		int columns;

		int Rows {
			get {
				return rows;
			}
			set {
				rows = value;
			}
		}

		int Columns {
			get {
				return columns;
			}
			set {
				columns = value;
			}
		}

		public Matrix (int rows, int columns)
		{
			this.rows = rows;
			this.columns = columns;
			elements = new T[rows * columns];
		}

		public T this[int i, int j] {
			get {
				return elements[i * rows + j];
			}
			set {
				elements[i * rows + j] = value;
			}
		}
	}
}

A linha

elements = new T[rows * columns];

Funciona perfeitamente. Pergunto então, existe uma situação insegura que Java previne e C# permite? Ou é o contrário, C#, mais moderna e recente, decidiu implementar Generics até a raiz da linguagem?

Etiquetado