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.

Bem, para começo de conversa, é bom lembrar que, no mundo computacional, as informações são representadas por combinações de zeros e uns. Cada um dos dígitos (zeros ou uns) utilizados nesta representação é conhecido por bit.

Hoje em dia os nossos computadores são (em sua maioria) de 32 bits ou 64 bits. Esse número indica que uma determinada informação é representada, computacionalmente, por um grupo de 32 ou de 64 bits. Por exemplo, em 32 bits o número inteiro 1 é representado por: 00000000000000000000000000000001.

Mas, como se representa um número inteiro negativo?

A solução mais adotada para solucionar este problema é, justamente, utilizar a notação em complemento de dois. Nesta notação, para saber se um número é positivo, ou negativo, basta observar o primeiro bit de cada conjunto/sequência. Se a sequência inicia-se com um 0 (zero) o número representado é positivo (não-negativo), caso contrário (a sequência inicia-se com o número 1) tem-se a representação de um número negativo.

12 bits

Para uma notação em complemento de dois, num sistema de n bits, os números que podem ser representados estão no seguinte intervalo: -2^(n-1) a 2^(n-1) -1.
Para saber como certo número (x) será representado (em binário) em um sistema (de n bits) em complemento de dois, aqui vai uma regra prática:

1. Se x >= 0, a representação é direta. Por exemplo, o binário que corresponde ao número cinco, em um sistema de oito bits é 00000101.
2. Se x < 0, primeiro deve-se calcular o valor da seguinte expressão: 2ⁿ + x. Em seguida, determina-se a representação do valor da expressão. Por exemplo, para o número -3:
   1. Valor da expressão: 2⁸ – 3 = 253
   2. Representação em binário: 11111101

Uma outra regra prática para determinar a representação de um negativo (inteiro, em complemento de dois) é:

1. Encontrar a representação de (-x)
2. Inverter bit a bit
3. Somar 1

Em síntese, esta expressão indica uma forma de representação de inteiros (positivos e negativos) que também é conhecida como complemento para dois. A expressão em inglês é signed two’s complement integer.

Bem, é isso… canseirinha essa parada… não é mesmo?

Se você quiser saber como é feita a representação de números reais, siga este link ou este.

Abraços.

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!