Pela internet correu solta a notícia: hoje a Canonical lançou o Ubuntu 11.04, apelidado de Natty Narwhal. Algumas mudanças recentes no Gnome já causaram certo burburinho (por exemplo a alteração da posição dos botões de controle da janela, que foram movidos da direita para a esquerda). Nesta nova versão o Ubuntu veio bem diferente:

Sim, o Gnome, gerenciador gráfico utilizado por padrão no Ubuntu desde seu nascimento perdeu lugar para o então chamado Ubuntu Unity. Quem tem netbook talvez já tenha tido a curiosidade de instalar a edição do Ubuntu especial para netbooks (que vem com o Unity). Eu fiz isso com o Ubuntu 10.10, e se não fosse pelo fraco desempenho, eu teria ficado com o sistema. Ao que tudo indica, esse problema foi sanado na versão 11.04. Quais as vantagens do Unity? Com ele você ganha espaço na tela, pela ausência dos dois painéis do Gnome, além de trazer a proposta de simplificar tarefas, centralizando tudo no painel lateral com ícones de fácil reconhecimento. Quando a janela está maximizada, a barra lateral fica oculta e a barra de títulos da janela ocupa o mesmo espaço que a barra superior (a que contém o relógio e itens de notificação), representando um significativo ganho de espaço para trabalho.

A IDGNow trouxe a manchete “Novo Ubuntu 11.04 trará quatro mudanças radicais“, relacionada a uma matéria publicada na PCWorld (com uma tradução pobre e diversos erros de concordância). Sinceramente, foi manchete pra vender conteúdo. A mudança mais significativa dentre as apontadas, a meu ver, é que o usuário poderá testar os aplicativos antes de instalar, pelo Ubuntu Software Center.

Mas e quanto às outras distribuições Linux? Como andam? Vamos falar de algumas delas.

Debian GNU/Linux

Debian é a distribuição da qual se derivou o Ubuntu, não por outro motivo senão sua qualidade. Sistema robusto com uma vasta quantidade de pacotes de fácil instalação, e contando com uma grande comunidade de desenvolvedores. A última versão estável do sistema foi lançada em fevereiro de 2011, o Debian 6.0, apelidado de Squeeze. A contar pelo histórico recente de atualizações do time Debian, podemos aguardar uma nova versão estável do sistema provavelmente no início de 2012. Se quiser conhecer mais sobre o Debian, visite http://www.debian.org/

OpenSUSE

O OpenSUSE é uma distribuição Linux livre e gratuita fundada e mantida pela Novell (que recentemente foi adquirida pela companhia The Attachmate Group), contando com um apoio que gostaria de destacar, a AMD (sim, a gigante que, em uma dita crise financeira, adquiriu a ATI e recentemente declarou que não iria mais usar essa marca em suas placas de vídeo). A versão mais recente do OpenSUSE foi lançada em 10/03/2011, o OpenSUSE 11.4. Você pode fazer o download visitando a página oficial: http://www.opensuse.org/

Fedora

O Fedora é uma distribuição mantida pela comunidade Red Hat e atualmente está na versão 14, que foi lançada em 02/11/2010. Esta versão recebe o codinome Laughlin. A versão 15 do Fedora, codinome Lovelock, é aguardada para 24/05/2011. O Fedora tem já certa maturidade no cenário Linux com seus 8 anos de história. Para conhecer mais sobre esta distro, acesse o site http://fedoraproject.org/

——————-

Então é isso pessoal, futuramente escreverei um artigo explicando como testar essas e outras distribuições Linux sem ter que reinstalar os sistemas operacionais do seu PC ou notebook. Até a próxima!

O CSS (Cascading style sheets) fornece ao programador todo o controle do posicionamento de elementos em um documento HTML. Desde que o CSS tornou-se a uma tecnologia promissora, surgiu a pergunta: qual é melhor, o design usando CSS ou tabelas HTML ?

• Há alguns anos, o suporte à scripts CSS evoluia lentamente, enquanto as tabelas HTML eram plenamente suportadas por todos os navegadores existentes. Hoje em dia, essa diferença diminuiu significativamente;
• As tabelas HTML são mais flexíveis quando a janela do navegador é redimensionada, reescalando e quebrando seus elementos, enquanto o CSS é mais preciso quanto ao posicionamento, porém bastante inflexível;
• As tabelas HTML são mais simples de serem manuseadas do que as regras CSS;
• O CSS evolui a cada dia, surgindo novas funcionalidades com tal evolução;
• Como dito anteriormente, o CSS é mais preciso do que as tabelas HTML, permitindo que a sua página seja visualizada exatamente da forma que o web designer desejar;
• O uso de CSS pode deixar o código bem mais organizado do que diversas tabelas aninhadas, facilitando a edição e leitura do código.

Assim, pesando os prós e contras de cada uma das técnicas, deve-se escolher qual delas é mais útil e adequada ao modo de trabalho do programador.

Olá, pessoas!

Esse artigo é dedicado aos usuários de gnuplot que necessitam dar aquela incrementada em seus gráficos, para facilitar a interpretação e chamar a atenção de quem os vê. O único pré-requisito para tal edição é exportar os gráficos para o forma Encapsulated Post Script, vulgo EPS.

Passo 01: Exportar os gráficos para EPS

Para exportar os gráficos para o formato EPS, basta colocar no fim de seu script Gnuplot as seguintes linhas:

set terminal postscript eps enhanced 20 color dashed
set output “arquivo.eps”
replot

Os termos na linha de comando que estão em itálico são opções da exportação, os quais podem ser trocados de acorodo com o desejado pelo usuário.

Passo 02: Instalando um editor de gráficos vetoriais

O formato EPS é um formato vetorial de imagens. Na prática, isso significa que a base da imagem não são os pixels, mas sim os pontos de curvaturas e cores da imagem, o que permite que você mude o tamanho, dê zoom na imagem sem perder resolução nem “serrilhar” a mesma. Um editor bem simples de usar e bastante potente é o Inkscape Vector Graphics Editor. Para instalá-lo, basta dar o comando:

sudo apt-get install inkscape

ou então acessar a página do programa (http://www.inkscape.org/) e baixar o pacote.

Passo 03: Transformando o EPS para PDF

Apesar de ser um ótimo editor de imagens, o Inkscape não consegue abrir figuras EPS, apenas salvar nesse formato. Sendo assim, é preciso transformar o arquivo para o formato PDF, o qual o Inkscape consegue abrir normalmente. Para isso, basta fazer:

epstopdf arquivo.eps

e será gerado o arquivo.pdf

Passo 04: Editando o arquivo PDF

Agora é só abrir o arquivo com o Inkscape. Abaixo tem um exemplo de como fica um gráfico aberto com o mesmo. Neste gráfico, a legenda do mesmo foi colocada alinhada verticalmente, para aproveitar melhor o espaço da figura.

Exemplo de gráfico aberto com o Inkscape

Após abrir o arquivo, é necessário desagrupar as linhas do gráfico. Para isso, basta clicar com o botão direito em cima da imagem e clicar em “Ungroup” sempre que um bloco estiver agrupado, assim será possível a edição de cada elemento do gráfico.

O Inkscape tem muito mais opções de cores, linhas, espessuras, pontilhados, além de outros atributos. Com isso, você conseguirá deixar seus gráficos muito mais claros e atraentes aos olhos de quem o analisa.

Para quem utiliza os dois sistemas operacionais na mesma máquina, é comum precisar de um arquivo que está em outra partição. No caso de estar no Linux e precisar de algo do Windows, o sistema possui ótimo suporte para partições FAT e até mesmo NTFS. Já o Windows, nada amigável com seus vizinhos, não tem qualquer interesse em “enxergar” um sistema de arquivos como o EXT2, EXT3 e ReiserFS. Mas tudo pode ser remediado.

Partição Ext2 no Windows

Ler partições EXT2 e EXT3 no Windows

Para executar tal tarefa, basta instalar o Ext2 IFS, que promete (e cumpre) a missão de tornar possível a leitura e escrita neste sistema de arquivos a partir do Windows (NT4.0/2000/XP/2003/Vista). Após a instalação, a partição assumirá uma letra que você designar, logo você poderá acessar seus arquivos abrindo o Windows Explorer e selecionando, por exemplo, a partição H: . O Ext2 IFS é um driver que adiciona ao ambiente Windows a capacidade de gerenciar este sistema de arquivos. Para baixar esse driver:

http://www.fs-driver.org/download/Ext2IFS_1_11a.exe

Ler partições ReiserFS a partir do Windows

Para quem faz uso do ReiserFS, há um software portátil para leitura e cópia dos dados. O software se chama YAReG, é super leve e simples, bom para quebrar aquele galho. Com ele você acessa os diretórios da partição, e tem a opção de copiar os dados para um outro local (por exemplo, uma partição NTFS, um pen drive, etc). Para baixá-lo:

http://yareg.akucom.de/index.html#DOWNLOAD

Bom pessoal, estes são os softwares que utilizo quando preciso acessar esses tipos de sistema de arquivos, há outros na internet, inclusive para XFS e outros, quem souber e quiser deixar aqui a dica para todos, fique à vontade!

Até a próxima!

Antes de qualquer outra palavra, gostaria de postar aqui um pedido de desculpas aos leitores, devido a diminuição considerável de novas postagens. Entretanto, os membros do time TS estão coincidentemente passando por períodos de mudanças e muito trabalho. Tentaremos, à medida do possível, voltar ao ritmo normal.  Bom, agora, com a cara de um cachorro que quebrou o vaso da dona, eu volto a falar-lhes sobre as novas “aventuras” da computação de alto desempenho, COMPUTAÇÃO HETEROGÊNEA!

A computação de alto desempenho contemporânea vem tomando rumos não imaginados há alguns anos atrás. Enquanto os computadores mais rápidos do mundo alternavam entre arquiteturas complexas e um número grande de processadores comuns, novas máquinas bastante potentes vem juntando diversas arquiteturas e componentes para ganhar desempenho com baixo custo.

O RoadRunner, o supercomputador mais rápido atualmente, é composto por processadores PowerXCell 8i 3.2 Ghz, os quais integram os velhos conhecidos PowerPC com alguns processadores auxiliares dentro de um mesmo núcleo, e por processadores Opteron DC 1.8 GHz. Os processadores AMD são responsáveis pelo controle dos dados, e os Cell fazem a parte pesada dos cálculos, resultando assim em cerca de 1,1 PFlops de desempenho.

Já o TSUBAME apresenta algo ainda mais inovador: mesclar processadores “comuns” AMD Opteron 2.4/2.6 GHz, Intel Xeon E5440 2.833 GHz com arquiteturas mais complexas, como o ClearSpeed CSX600, processadores dedicados a operações matemáticas, além do uso de placas de vídeo nVidia GT200, auxiliando nos cálculos massivos com o CUDA.

Com a tecnologia de integração, fica mais fácil a integração de sistemas já existente para obter mais performance. Assim, se esta vertente da HPC (High Performance Computing) firmar-se como tendência mundial, veremos um número muito grande de sistemas contendo diversas tecnologias antes usadas separadamente, o que parece ser bom, pois o custo de tecnologias Off-the-shelf são menores que os produtos de ponta. Assim, teremos máquinas potentes em computadores pessoais, e não somente em grandes pólos.

See ya!

Em meus primeiros passos no aprendizado de programação em CUDA, tive um problema muito básico, mas que foi difícil encontrar a solução do mesmo: como compilar um programa escrito em C++ for CUDA ???

Vejamos um exemplo de código, o arquivo teste.cu

//**********************************************************************************************

cudaArray* cu_array;
texture<float, 2> tex;

// Allocate array
cudaMallocArray(&cu_array, cudaCreateChannelDesc<float>(), width, height);

// Copy image data to array
cudaMemcpy(cu_array, image, width*height, cudaMemcpyHostToDevice);

// Bind the array to the texture
cudaBindTexture(tex, cu_array);

// Run kernel
dim3 blockDim(16, 16, 1);
dim3 gridDim(width / blockDim.x, height / blockDim.y, 1);
kernel<<< gridDim, blockDim, 0 >>>(d_odata, width, height);
cudaUnbindTexture(tex);

__global__ void kernel(float* odata, int height, int width)
{
unsigned int x = blockIdx.x*blockDim.x + threadIdx.x;
unsigned int y = blockIdx.y*blockDim.y + threadIdx.y;
float c = texfetch(tex, x, y);
odata[y*width+x] = c;
}
//**********************************************************************************************

Para compilar este programa, primeiramente é necessário ter o compilador nvcc instalado, por meio das bibliotecas fornecidas pela NVidia.

Temos então a seguinte sequência de comandos:

nvcc -cuda teste.cu

Este comando irá gerar um código C++ a partir do arquivo teste.cu, guardando-o no arquivo teste.cu.cpp. Após isso, faz-se:

nvcc teste.cu.cpp -o teste.exe

E assim, teremos o executável tão desejado!

Espero que ajude!

See ya!

Buenas, caros leitores!

Hoje venho aqui para uma nota rápida, porém bastante interessante. Você, usuário de distribuições Linux Debian-based (Ubuntu, Debian), sabe como configurar o desempenho de seu processador pelo sistema operacional ?

Por padrão, os processadores vem configurados no modo de economia de energia. Porém, em alguns casos, como o meu, queremos extrair cada recurso daqueles milhões de transistores em forma de pastilha. Uma opção é realizar a configuração na BIOS, porém há uma opção bastante interessante: o aplicativo cpufreq-selector.

Há as seguintes opções:

• -c ‘número do processador’ – para informar o número da CPU a ser configurada, no caso de otimizar apenas um dos núcleos de um processador multicore;
• -g ‘opção’ – para configurar o modo de operação de seu processador, com as opções powersave (economia de energia) e performance (para alto desempenho);
• -f ‘frequência’ – para setar a frequência de operação do seu processador, em KHz

Sendo assim, para configurar seu processador, usa-se o comando:

cpufreq-selector -n ‘#proc’ -g ‘modo’ -f ‘freq’

Assim, é possível ajustar o desempenho de seu processador via sistema operacional, de acordo com suas necessidades!

See ya!

O Fortran (FORmula TRANslator)  surgiu na década de 50, e veio evoluindo desde então. Nos primórdios de sua existência a programação era feita em cartões perfurados, e os programas eram executados em máquinas monoprogramadas executavam apenas um job por vez). Com o tempo, a linguagem evoluiu juntamente com os computadores que foram surgindo.

Entretanto, nesse meio tempo, outras linguagens surgiram. Após o grande sucesso da linguagem C e derivadas, fica no ar a pergunta: é preciso usar o Fortran ?

Um dos fatores responsáveis por essa indagação é ausência de ponteiros em Fortran, assim como a diferente forma de alocação de dados na memória. Em C, uma matriz é alocada da seguinte forma: os elementos de uma mesma linha são alocados sequencialmente na memória. Já no Fortran, os elementos de uma mesma coluna são alocados consecutivamente. Entretanto, poucas pessoas sabem dos bons atributos do veterano Fortran. É uma das poucas linguagens que possuem paralelismo em sua definição. Em apenas uma linha é possível realizar o produto elemento a elemento de duas matrizes, assim como soma e outras operações, sem uso de bibliotecas auxiliares. Além disso, devido ao seu grande uso pela comunidade científica, o Fortran é bastante otimizado para a computação de alto-desempenho, como o HPF (High Performance Fortran), uma extensão do Fortran otimizada para arquiteturas potentes e bibliotecas de otimização. Além disso, o Fortran é compatível com protocolos de comunicação para multiprocessamento (MPI, OpenMP e outros), permitindo obter desempenhos fantásticos em programas com grande volume de dados processados. Em programas que envolvem basicamente operações com matrizes, o Fortran é fenomenal!

Evidentemente, outras linguagens possuem grande desempenho, otimizações e bibliotecas auxiliares para resolver todo tipo de problema. Mas não podemos deixar o quase “sessentão” Fortran de lado devido a sua idade. Por mais que seja um “idoso”, está melhor que muita linguagem de 20 anos por aí.

Olá caro leitor, depois de algum tempo de descanso volto novamente a tratar de um assunto que tem tido bastante interesse da comunidade que trabalha com computação de alto desempenho. Pois uma forma de conseguir o tão desejado alto desempenho em um programa é fazendo com que este utilize vários processadores durante sua execução, mas como foi dito no último artigo que escrevi ( Implementando Programas que Usam Vários Processadores ), essa não é uma tarefa tão simples! O escopo desse artigo traz algumas dicas de ferramentas necessárias para criar um programa que ao ser executado use vários processos e que esses processos comuniquem entre si.

Como foi discutido no artigo citado acima, uma forma de implementar a programação paralela é usando as bibliotecas de passagem de mensagens (MPI). Portanto, se o leitor quiser testar os programas exemplos que darei durante os próximos artigos será necessário instalar o MPI, como sou adepto da filosofia Open Source, aconselho que instale o Open MPI,( mas se estiver usando o Windows, instale o MPICH, Por sua conta e risco). Como de praxe, a instalação do Open MPI é simples, basta baixar o código fonte (código fonte), descompactar o arquivo, entrar na pasta criada pela descompactação usando o console ou um aplicativo similar e em seguida dar os comandos usais para compilação e instalação de pacotes (./configure em seguida make, e como superusuário dar o último comando, make install). O Open MPI necessita de que alguns pacotes estejam instalados; por exemplo, se você quiser escrever seus programas em Fortran, será necessário que tenha o fortran previamente instalado em sua máquina, essa mesma regra é válida para as outras linguagens que você queira escrever seus códigos, tais como C e C++. Outro pacote que o MPI usa e, portanto, deve estar instalado é o ssh, pois é a partir do ssh que é feita a comunicação entre os vários processos do programa em execução.

Vamos criar um programa simples para verificar se sua instalação foi bem sucedida, porém primeiramente vou falar de uma premissa básica sobre o MPI que é a Inicialização e a Finalização. Para se fazer referências ou chamadas à qualquer rotinas MPI, é necessário que o MPI seja inicializado e antes do término do programa principal o MPI deve ser finalizado. Para isso são definidas rotinas nas linguagens de programação, aqui vou usar o C como exemplo, porém o procedimento é o mesmo para outras linguagens (o que muda é sintaxe da chamada da rotina).

int MPI_Init( int *argc,  char ***argv); // inicialização do  MPI

//Blocos de códigos  MPI

int MPI_Finalize( ); // finalização do MPI

Esses parâmetros definidos na inicialização do MPI (argc e argv), são aqueles parâmetros recebidos tradicionalmente pela interface da linguagem C, portanto tais parâmetros devem ser passados para inicializar o MPI antes de sua utilização. O valor de retorno dessa chamada é um código de erro, sendo assim, ele indica possíveis erros durante a inicialização do MPI. Se não houve nenhum erro durante a inicialização, o valor de retorno será MPI_SUCCESS; caso haja algum tipo de erro os valores serão diferentes, porém não são especificados pelo MPI.  E assim como a inicialização, a finalização é feita pela rotina MPI_Finalize( ).

Para compreender o processo de  inicialização e finalização das rotinas MPI bem como testar se a sua instalação foi bem sucedida, copie o trecho do código seguinte em um arquivo sem formatação e salve-o com o nome NumProcesso.c em seguida compili-o. Obs. Ao copiar e colar tome cuidado com as aspas!

#include <stdio.h>
#include <mpi.h>

int main(int argc, char **argv){
int quantos, rank;
MPI_Init(&argc, &argv);
MPI_Comm_size(MPI_COMM_WORLD, &quantos);
MPI_Comm_rank(MPI_COMM_WORLD, &rank);
printf(“Processo %d de %d rodando \n”, rank, quantos);

MPI_Finalize();

return 0;

}

Para compilar um arquivo usando MPI basta seguir o seguinte procedimento: usando o console, entre na pasta que se encontra o arquivo e em seguida dê o comando mpicc NumProcesso.c -o processos.exe (obs. a extensão *.exe é opcional, na verdade nem é necessário usar nenhum tipo de extensão). Se a compilação ocorreu tudo certo, execute o programa recém compilado assim: mpirun -np 4 processos.exe, aqui “-np 4″ é o numero de processos que será aberto durante a execução do programa, neste caso são quatro processos. Para evitar que a cada processo aberto ele peça a senha, configure o servidor ssh para autenticação sem senha.

P.S. O Próximo artigo será: Os conceitos em que as rotinas MPI são construídas. Nesse artigo será abordado processos,  mensagens,  comunicadores e tipos de dados.

ERRATA:

Olá leitores do TecnoSapiens, em algum ponto do artigo foi afirmado que a comunicação entre os processos era feita pelo ssh, porém o ssh é utilizado para disparar os daemons responsáveis por executar os processos MPI. Normalmente a comunicação propriamente dita das primitivas MPI_ …  é feita sem segurança.

Claudinei Caetano de Souza.

Sabe quando você está passeando por aí e se depara com um carro modificado pelo dono, com detalhes aerodinâmicos, rodas de liga leve e aquelas famigeradas e, por que não dizer, bregas luzes azuis debaixo da carroceria? Aquilo se chama Car Tuning, e os carros são “tunados”.

Mas a idéia do artigo não é personalizar o OpenOffice (no Brasil chamado de BrOffice) para deixá-lo mais bonitinho. Na verdade venho apresentar o que uma equipe de desenvolvedores criou tendo como base o OpenOffice: o Go-oo. Este novo software promete ser mais compatível com formatos de arquivos do Microsoft Office, mais livre, mais rápido e mais funcional. Com isto em mente, resolvi baixar e instalar o dito cujo, para ter uma noção.

Após fazer o download através desse endereço (baixei também o pacote de linguagem pt-BR), e instalação no Windows XP, me deparo com essa tela de boas-vindas típica da versão 3.0 do OpenOffice:

Comecei a testar alguns recursos. A suíte tem um tempo de carregamento inferior ao do OpenOffice, tem um ótimo suporte para importação de arquivos SVG, e também melhor compatibilidade com documentos em formato Microsoft Office, inclusive cálculos em planilhas do Excel e preenchimento de formulários . Ainda assim, percebi problemas de formatação na edição de arquivos Docx, tanto no OpenOffice quanto no Go-oo.

Meu conselho: pare de usar formatos proprietários, e se não for possível, pelo menos evite Docx. Infelizmente ainda vai levar algum tempo até se alcançar uma ótima compatibilidade com formatos da Microsoft, mas importante valorizar os avanços que a comunidade alcançou até hoje. Ah, e se tiver um carro, não coloque neon nele; isso não fará de você uma pessoa mais descolada.

Links:

Sobre o OpenDocument Format
Saiba mais sobre o Openoffice.org