Adicionar SWAP no Linux

hoboken-swap-meet-2

Para adicionar swap no Linux basta seguir os comandos:

sudo /bin/dd if=/dev/zero of=/var/swap.1 bs=1M count=1024
sudo /sbin/mkswap /var/swap.1
sudo /sbin/swapon /var/swap.1

Para mantê-la mesmo após o reboot, adicione isso ao /etc/fstab:

/var/swap.1 swap swap defaults 0 0

Tutorial: Como instalar o IIS no Windows 7

Para instalar o IIS no Windows 7 é bem smples, basta ir no Painel de Controle e clicar em Programas.

Clique no link Turn Windows features on or off e ele abrirá a seguinte janela:

Selecione o IIS e confirme. Depois disso basta aguardar a instalação.

Fonte: http://www.howtogeek.com/howto/windows-vista/how-to-install-iis-on-windows-vista/

Tutorial: Como utilizar SVN no Visual Studio 2010

Nativamente o Visual Studio não tem suporte ao uso de svn. Para isso faz-se necessário a instalação do ASKHSVN, um plugin Open Source que faz a integração do Visual Studio com o SVN.

Após instalado é preciso configurar no Visual Studio que ele deve usar o ASKHSVN. É bem simples, basta ir no Menu Tools -> Option -> Source Control -> Plugin Selection e mudar de Team Foundation para ASKHSVN.

Há todas as instruções aqui.

Meu Ubuntu não está detectando as resoluções que meu monitor suporta e a padrão está sendo 1024×768. Não consegui inserir as novas resoluções, mas consigo rodar um script quando faço o login que insere a resolução e seta.

Para meu monitor que suporta 1680×1050 o script foi o seguinte:

xrandr –newmode “1680×1050″ 106.5 1440 1520 1672 1904 900 901 904 932 -HSync +VSync
xrandr –addmode VGA1 1680×1050

Tutorial: Como instalar Java 7 no Ubuntu 11.10

A instalação é feia via PPA de acordo com os próximos 3 passos:

sudo add-apt-repository ppa:webupd8team/java
sudo apt-get update
sudo apt-get install oracle-jdk7-installer

Algumas vezes faz-se necessário obter algumas informações sobre algum módulo e nesse post mostra-se como carregar essas informações e é dado dois exemplo: como carregar a versão e como carregar os tipos. Antes é preciso inserir: using System.Reflection;

Para carregar basta fazer isso:

Assembly _Assemblies = Assembly.LoadFrom(“modulo.dll”);

Para obter a versão basta fazer isso:

string versaoAssembly = _Assemblies.GetName().Version.ToString();

Para carregar os tipos basta fazer isso:

Type[] _AllTypes = _Assemblies.GetTypes();

Para saber se um determinado tipo herda de outro basta usar o BaseType até encontrar object. Dessa maneira aqui:

bool eDoTipoQueQuero = false;
while (itemASerChecado != typeof(object)) {
 if (itemASerChecado == typeof(TipoQueQueroProcurar)) {
 eDoTipoQueQuero = true;
 break;
 }

 itemASerChecado = itemASerChecado.BaseType;
}

if(eDoTipoQueQuero){
 ...
}

SQL Server: Deletar todas as tabelas do banco

Para deletar todas as tabelas de um banco SQL Server basta ir no Management Studio, clicar com o botão direito em cima do banco e escolher a opção Nova Consulta. Cole esse script e clique em Executar. Se preferir, pode ser melhor visualizador aqui.

/* Drop all non-system stored procs */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = ‘P’ AND category = 0 ORDER BY [name])
WHILE @name is not null
BEGIN
SELECT @SQL = ‘DROP PROCEDURE [dbo].[' + RTRIM(@name) +']‘
EXEC (@SQL)
PRINT ‘Dropped Procedure: ‘ + @name
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = ‘P’ AND category = 0 AND [name] > @name ORDER BY [name])
END
GO

/* Drop all views */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = ‘V’ AND category = 0 ORDER BY [name])
WHILE @name IS NOT NULL
BEGIN
SELECT @SQL = ‘DROP VIEW [dbo].[' + RTRIM(@name) +']‘
EXEC (@SQL)
PRINT ‘Dropped View: ‘ + @name
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = ‘V’ AND category = 0 AND [name] > @name ORDER BY [name])
END
GO

/* Drop all functions */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] IN (N’FN’, N’IF’, N’TF’, N’FS’, N’FT’) AND category = 0 ORDER BY [name])
WHILE @name IS NOT NULL
BEGIN
SELECT @SQL = ‘DROP FUNCTION [dbo].[' + RTRIM(@name) +']‘
EXEC (@SQL)
PRINT ‘Dropped Function: ‘ + @name
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] IN (N’FN’, N’IF’, N’TF’, N’FS’, N’FT’) AND category = 0 AND [name] > @name ORDER BY [name])
END
GO

/* Drop all Foreign Key constraints */
DECLARE @name VARCHAR(128)
DECLARE @constraint VARCHAR(254)
DECLARE @SQL VARCHAR(254)
SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘FOREIGN KEY’ ORDER BY TABLE_NAME)
WHILE @name is not null
BEGIN
SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘FOREIGN KEY’ AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
WHILE @constraint IS NOT NULL
BEGIN
SELECT @SQL = ‘ALTER TABLE [dbo].[' + RTRIM(@name) +'] DROP CONSTRAINT ‘ + RTRIM(@constraint)
EXEC (@SQL)
PRINT ‘Dropped FK Constraint: ‘ + @constraint + ‘ on ‘ + @name
SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘FOREIGN KEY’ AND CONSTRAINT_NAME <> @constraint AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
END
SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘FOREIGN KEY’ ORDER BY TABLE_NAME)
END
GO

/* Drop all Primary Key constraints */
DECLARE @name VARCHAR(128)
DECLARE @constraint VARCHAR(254)
DECLARE @SQL VARCHAR(254)
SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘PRIMARY KEY’ ORDER BY TABLE_NAME)
WHILE @name IS NOT NULL
BEGIN
SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘PRIMARY KEY’ AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
WHILE @constraint is not null
BEGIN
SELECT @SQL = ‘ALTER TABLE [dbo].[' + RTRIM(@name) +'] DROP CONSTRAINT ‘ + RTRIM(@constraint)
EXEC (@SQL)
PRINT ‘Dropped PK Constraint: ‘ + @constraint + ‘ on ‘ + @name
SELECT @constraint = (SELECT TOP 1 CONSTRAINT_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘PRIMARY KEY’ AND CONSTRAINT_NAME <> @constraint AND TABLE_NAME = @name ORDER BY CONSTRAINT_NAME)
END
SELECT @name = (SELECT TOP 1 TABLE_NAME FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS WHERE constraint_catalog=DB_NAME() AND CONSTRAINT_TYPE = ‘PRIMARY KEY’ ORDER BY TABLE_NAME)
END
GO

/* Drop all tables */
DECLARE @name VARCHAR(128)
DECLARE @SQL VARCHAR(254)
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = ‘U’ AND category = 0 ORDER BY [name])
WHILE @name IS NOT NULL
BEGIN
SELECT @SQL = ‘DROP TABLE [dbo].[' + RTRIM(@name) +']‘
EXEC (@SQL)
PRINT ‘Dropped Table: ‘ + @name
SELECT @name = (SELECT TOP 1 [name] FROM sysobjects WHERE [type] = ‘U’ AND category = 0 AND [name] > @name ORDER BY [name])
END
GO

GPU: O que é e como interfere no computador

A GPU (Graphics Processing Unit) é o componente mais importante de uma placa de vídeo e é um processador feito para realizar cálculos para o processamento gráficos em tempo real. A ideia é tirar essa tarefa do processador principal e ter um processador específico para isso, feito e adaptado para realizar essas funções com o melhor desempenho e qualidade possível. Há diversos modelos de GPU, cada uma com suas vantagens e desvantagens e, para baratear custos, as mais simples são integradas diretamente à placa mãe.  Para quem busca desempenho, o melhor é ter uma placa de vídeo com uma GPU de boa qualidade.

As GPUs não são de uso exclusivo de computadores, elas ganharam espaço no mercado de videogames para provê alta qualidade em imagens em alta definição com um desempenho excelente nos jogos de diversos consoles, tais como o PlayStation e o XBox. Esses microprocessadores tem um desempenho tão aceitável que há diversas pesquisas na criação de clusters com o intuito de obter um poder de processamento maior. Seu poder é tamanho que reproduziram isso quebrando o algoritmo MD5 com um cluster do console PlayStation 3.

O que a GPU tem de diferente para ser tão melhor nessa função que os processadores comuns? Para se ter uma ideia do quão melhor é a GPU para processamentos gráficos, veja a comparação entre nesse vídeo aqui, que contém a renderização de um fluido que levou 1:30 com uma CPU e 0:10 com uma GPU. A GPU não participa diretamente da renderização do vídeo em si, mas o ponto principal são os cálculos da física que estão relacionadas ao vídeo. É nesse ponto que seu desempenho é muito superior ao de uma CPU e por isso seu desempenho para obter a renderização do vídeo em tempo real foi bem melhor. Nesse outro exemplo é possível observar também a renderização de um vídeo que envolve muita física.

GPUs têm diferentes estágios e em cada um desses estágios os dados são transformados de acordo com algumas regras. Um grande problema nesse tipo de estrutura de operações é que criam um pipeline relativamente grande e, em determinados momentos, isso pode ser prejudicial para a performance. Os softwares são escritos e se comunicam com a CPU. A GPU está por traz da CPU se comunicando com ela com o intuido de realizar os processamentos gráficos. Todos os comandos feitos pelo software são armazenados em um buffer que são feitas algumas verificações, tal como a verificação se não são comandos redundantes. Quando o buffer está cheio ou quando um frame precisa ser exibido, esses comandos são enviados para serem calculados. Esse processamento é feito em paralelo com a CPU, que fica livre para fazer outras coisas. Todo o resultado dos cálculos é inserido em um outro buffer e apenas quando é necessário desenhar que esse buffer é esvaziado e seu conteúdo é pintado na tela. Isso evita os flicados que ocorreria se a cada redesenho de um objeto a tela fosse alterada, esses redesenhos são agrupados e pintados todos juntos. Essa é uma visão macro de como funciona uma GPU, pois internamente seu funcionamento é muito mais complicado.

O mercado de GPUs é sustentado pelos jogos já que estes forçam ter imagens de boa qualidade com físicas reais e em tempo real, é nesse ponto que a GPU entra, diferente de uma renderização comum que o impacto no tempo não é tão fundamental. Cada fabricante tem suas estratégias de desenvolvimento da GPU e cada uma pode ter suas características positivas e negativas em relação a outros, mas a CPU foi feita para ser de propósito geral e não atende ao desempenho exigido para processamentos gráficos pesados, enquanto a GPU está preparada para isso. Vale salientar que a CPU trabalha independentemente de GPU, mas a GPU trabalha em paralelo com a CPU, ou seja, ela não a substitui, ela a complementa.

Resenha da Unidade 10 de Arquitetura de Computadores
Programa de Pós-Graduação em Informática – PPGI
Universidade Federal da Paraíba – UFPB

Fontes:

  • FAN, Z. QIU, F. KAUFMAN, A. YOAKUM-STOVER, S. GPU Cluster for High Performance Computing. Supercomputing. Proceedings of the ACM/IEEE SC2004 Conference. 2004.
  • MCDONNEL, B. ELMQVIST, N. Towards Utilizing GPUs in Information Visualization: A Model and Implementation of Image-Space Operations. Visualization and Computer Graphics, IEEE Transactions on. Volume: 15. 2009.

FPGA: O Lego da Informática

Figura 1: Chip FPGA da Altera

Não basta ser expert para perceber que os softwares produzidos por qualquer empresa sempre tem erros e inúmeras atualizações são geradas para corrigi-los. Fazendo uma breve comparativo entre um hardware e um software, um software tem certas vantagens por permitir sua reprogramação. Os programadores tem a vantagem de poder fazer, gerar uma versão e testar em um ambiente de produção, já com o hardware isso também é possível, porém com um custo bem mais elevado e a versão gerada fica perdida. Seria interessante que tivesse um hardware que se comportasse como um software para que o programador pudesse programar, gerar versão e testar em um ambiente de produção. Ele hardware existe e faz parte da classe de Arquiteturas Reconfiguráveis. Nessa resenha crítica é feito um panorama geral do que são arquiteturas reconfiguráveis, sua representante mais famosa e o que é possível fazer ou  não com essas arquiteturas.

A Field Programmable Gate Array (FPGA), como pode ser vista na Figura 1, é a mais famosa representante das arquiteturas reconfiguráveis. Há diversos kits para atender às mais diversas necessidades e contextos em que hardwares são empregados. Traduzindo sua sigla, o Arranjo de Portas Programáveis em Campo é um dispositivo semicondutor que pode ser programado mesmo após ser construído. Isso permite baratear os custos dos testes que envolvem hardware.  Uma FPGA já vem pronta com ligações pré-definidas que permites ser ligadas ou não e isso pode ser feito e refeito diversas vezes e vem com interfaces de comunicação para serem conectadas com placas e se tornarem o “cérebro” de um circuito integrado.

Surge uma pergunta: é possível fazer qualquer coisa com FPGA? As FPGAs vem pré-configurada com suas ligações já existentes, cabe o programador ativar ou não essas ligações e fazer sua lógica em cima disso. É possível fazer muita coisa com esses chips, mas essas possibilidades estão limitadas ao que o hardware permite fazer.

Existem vários softwares que permitem fazer programação em FPGA, montar a arquitetura e depois passar essa programação para o chip, processo esse que é conhecido como “queimar” o chip. O fabricante que mais se destaca é a Altera, uma gigante do meio. Normalmente a programação das placas é feita utilizando a VHSIC Hardware Description Language (VHDL) onde VHSIC significa Very High Speed Integrated Circuits e é feita utilizando algum software, como, por exemplo, o Max Plus II, da Altera, que pode ser visualizado na Figura 2.

Figura 2: Max Plus II da Altera

Programar em VHDL e produzindo FPGAs não é a melhor ou mais fácil tarefa para quem quer trabalhar com hardware, nem mesmo permite alcançar a flexibilidade que há com o trabalho com software, mas permite ao programador fazer verificações sobre o hardware produzido e diminuir a perda em chips fabricados com erros. Mesmo não sendo possível fazer tudo, a reprogramação da FPGA dá ao programador de hardware tem uma flexibilidade bem maior e possibilita a criação de hardwares com menos erros e de melhor qualidade. Um bom emprego dessas arquiteturas são nas universidades, onde os recursos são limitados e possibilita o contato do aluno com a parte prática da produção de hardware.

Resenha da Unidade 9 de Arquitetura de Computadores
Programa de Pós-Graduação em Informática – PPGI
Universidade Federal da Paraíba – UFPB

Fontes:

  • GROSSO, M. REORDA, M. S. Exploiting Embedded FPGA in On-line Software-based Test Strategies for Microprocessor Cores. IOLTS 2009: 15th IEEE International On-line Testing Symposium. Lisboa, Portugal. 2009.
  • CIVERA, P. MACHIARULO, L. REBAUDENGO, M. REORDA, M. S. VIOLANTE, M. An FPGA-based approach for speeding-up Fault Injection campaigns on safety-critical circuits. Journal of Electronic Testing:Theory and Applications. Junho, 2002.
  • <www.altera.com/products/fpga.html>. Acesso em 7 de dezembro de 2011.

Palestra: Front Side Bus (FSB)

No dia 30 de novembro de 2011 fiz uma apresentação sobre Front Side Bus (FSB). Essa apresentação fez um panorama geral do FSB e a comparação com as soluções de AMD e Intel que visam tirar funções do FSB com o princípio de tirá-lo da arquitetura, a Hyper Transport e a QuickPath Interconnect, respectivamente. A apresentação contou também com vídeos ilustrativos do funcionamento do FSB e dessas soluções além de falar um pouco sobre overclock.

A apresentação pode ser baixada aqui.

Apresentação da Unidade 8 de Arquitetura de Computadores
Programa de Pós-Graduação em Informática – PPGI
Universidade Federal da Paraíba – UFPB

Produzido por Elenilson Vieira