Lembrete para conversão de base no Python, a primera coluna é o valor de entrada e a primeira linha o valor de saída.

Pode-se converter para outras bases entre 2 e 36 utilizando int(<numero>,<base>), exemplo:

>>> print int('g',18)
16

Posted in programação Tagged: python ]]> http://escovandobits.wordpress.com/2009/07/05/conversao-de-base-no-python/feed/ 0 Tiago Maluta http://escovandobits.wordpress.com/2009/05/23/vmware-esx/ http://escovandobits.wordpress.com/2009/05/23/vmware-esx/#comments Sat, 23 May 2009 04:48:43 +0000 Tiago Maluta http://escovandobits.wordpress.com/?p=483 ]]>

Ainda não testei num hardware apropriado… mas hoje quando fiz um teste rápido com com o VMware ESXi no QEmu percebi que ele detectou “aonde” estava rodando.

Para ver mais screenshots clique aqui.

As CPUs modernas possuem alguns registros especiais dentre os quais há o grupo de instruções: Memory Type Range Registers (MTRRs) que provém um sistema de como o acesso a faixas de memória são transferidas para a cache. Nesse caso a mensagem [No variable MTRRS] indica como o VMware detectou.  [assim que sobrar um tempo irei buscar a fundo o motivo real da virtualização não implementar isso]

Utilizei o seguinte comando para rodar o Qemu:

./qemu -cpu coreduo -m 1500 \
 -hda vm.cow \
 -cdrom VMware-VMvisor-InstallerCD-3.5.0_Update_4-153875.i386.iso

A título de exemplo,  vejam um programa para detectar se o seu programa está em uma máquina virtual (no caso VMware):

#include <stdlib.h>
#include <unistd.h>
#include <signal.h>

#define MAGIC 0x564d5868 /* "VMXh" */
#define PORT 0x5658       /* "VX" */
#define GETVERSION 0x0a

static char *versions[] =
  {"??","Express","ESX Server","GSX Server","Workstation" };

static int vlen[] = {2,7,10,10,11};

static void segfault(){
    write(1,"Not a VMware box.\n",18);
    exit(1);
}

int main(){
    unsigned int ok, ver, magic;

    signal(11, segfault);
    __asm__ __volatile__ (" \
         push %%ebx          \n\
         in %%dx, %%eax      \n\
         mov %%ebx, %1       \n\
         pop %%ebx           \n\
       "
       : "=a"(ok), "=m"(magic), "=c"(ver)
       : "0" (MAGIC), "c" (GETVERSION), "d" (PORT)
    );

    if (magic == MAGIC) {
       write(1, "VMware ", 7);
       if (ok == 6) {
               write(1, versions[ver], vlen[ver]);
               write(1, "\n", 1);
       }
       else write(1, "unknown\n",8);
    }
    else write(1, "Not vmware\n",11);
    exit(0);
}

Isso foi só um motivacional. Isso é assunto para outros posts, ainda estou aprendendo as metodologias utilizadas em virtualização,  esperem em breve posts com temas interessantíssimos.

Esse post irá mostrar uma pequena dica para quem deseja começar a testar programas de terceiros de uma forma organizada, de modo a preservar os “originais” do sistema e permitir isolar as versões.

Na maioria dos casos quando testamos um programa pelo código-fonte, utilizamos a forma definida no autoconf, muito tradicional no sistema GNU, onde:  descompactamos, verificamos o sistema (configure),  compilamos (make) e copiamos para a pasta correspondente na hieraquia de pastas do sistema (make install).

 tar zxvf programa.tar.gz
 cd programa
 ./configure
 make
 make install

Contudo, se estamos trabalhando com versões de desenvolvimento não queremos copiar os binários gerados para o sistema.  Pode ser que eu tenha uma versão X do software funcionando e a verão Y que desejo testar quebre a compatibildade com algum outro programa do sistema.  Vamos considerar o seguinte exemplo: suponha que você viu no site do projeto binutils que há um novo linker (A new, faster, ELF only linker, still in beta test.) e deseje compilar esta nova versão para testá-la. Utilizando o processo descrito acima você irá sobreescrever a versão distribuida pelos desenvolvedores da sua distribuição e não queremos que isso ocorra, principalmente quando o software está na versão beta do seu desenvolvimento. Vamos pensar outra maneira:

 wget http://ftp.gnu.org/gnu/binutils/binutils-2.9.tar.gz
 tar zxvf binutils-2.9.tar.gz
 cd binutils-2.9

Se olharmos as opções de ajuda (–help) do script configure vemos que podemos setar o prefixo da instalação:

 --prefix=MYDIR          install into MYDIR [/usr/local]

Então basta escolher o diretório para colocar os executáveis.

 ./configure --prefix=../install

Mas ainda há uma maneira, ao meu ver, mais organizada, principalmente se você está desenvolvendo um software. Depois de descompactar o programa, crie dois diretórios: um chamado build que irá conter os arquivos gerados pelo compilador e um install que terá apenas os executáveis.

 cd ..
 mkdir build install

No final teremos os diretórios:

 .
 |-- binutils-2.9
 |-- build
 `-- install

Uma pasta com o código-fonte, outra com os arquivos objeto (resultado da etapa de compilação) e o executáveis.

 cd build
 ../binutils-2.9/configure --prefix=$(cd ../install && pwd)

Depois disso siga normalmente o processo de make e make install lembrando que os executáveis agora ficarão na pasta install/.  Essa metodologia é simples e muito útil,  principalmente quando estamos trabalhando com algum programa de controle de versão (ex.: git) e desenvolvendo testes em arquiteturas diferentes.

Caso especial: kernel

O Linux não possui um script de configuração (configure) portanto é preciso especificar no ‘make’ no local. Para manter a mesma árvore compilando para diferentes arquiteturas.

alias make-cross= \
"make O=../buildsh ARCH=sh CROSS_COMPILE=sh4-unknown-linux-gnu-"
make-cross menuconfig
make-cross

O Motorola 6800 não possui uma instrução específica para divisão de dois números. Uma solução simples é fazer a divisão através de múltiplas subtrações. Contudo, podemos pensar mecanismos mais eficientes. Uma solução  esta descrita no código-abaixo. Esse algoritmo é mais eficiente na maiora dos casos, pois com apenas 8 deslocamentos efetua a divisão de dois números de 8 bits.

O primeiro caso é quando temos números absolutos.

                LDAA Divisor       
                BEQ __end        ; caso Divisor = 0

                ; o contador ira deslocar 8 vezes,
                ; mas como já começo decrementando
                ; carrego com 9.

                LDAA #$09      
                STAA Contador
                CLRA
                BRA loop_div

empurra_zero:   ASL Resposta  

loop_div:       DEC Contador  ; decrementa contador
                BEQ __end

                ASL Dividendo ; desloca o dividendo p/ Carry
                ROLA          ; desloga do Carry p/ ACCA
                CMPA Divisor  ; Acumulador - Dividor > 0

                BCS empurra_zero

                SEC           ; set carry 
                ROL Resposta  ; empurra '1' na resposta
                SUBA Divisor
                BRA loop_div

__end:          NOP

Se os números forem sinalizados precisamos considerar isso na conta, portanto antes de dividir o número devemos verificar seu sinal. O código abaixo utiliza duas posições de memória para o sinal do número.  No final é feito uma OU-Exclusivo para definir qual sinal da resposta.

            CLR Neg_Divisor
            CLR Neg_Dividendo               
            LDAA Divisor
            BEQ __end        ; caso Divisor = 0
            BPL skip

            NEG Divisor
            DEC Neg_Divisor  ; Neg_Divisor = 1 (0xff)

skip:       LDAA Dividendo
            BPL __div        ; Neg_Dividendo = 1 (0xff)

            NEG Dividendo
            DEC Neg_Dividendo

            ; o contador ira deslocar 8 vezes, mas
            ; como já começo decrementando
            ; carrego com 9.

__div:          LDAA #$09      
                STAA Contador
                CLRA
                BRA loop_div

empurra_zero:   ASL Resposta  

loop_div:       DEC Contador   ; decrementa contador
                BEQ __end

                ASLA Dividendo ; desloca o dividendo p/ Carry
                ROLA           ; desloga do Carry p/ ACCA
                CMPA Divisor   ; Acumulador - Dividor > 0

                BCS empurra_zero

                SEC           ; set carry 
                ROL Resposta  ; empurra '1' na resposta
                SUB Divisor
                BRA loop_div

__end:          LDAA Neg_Divisor
                EORA Neg_Dividendo 
                ; a lógica da XOR garante o estudo dos sinais
                BPL _end 

                NEG Resposta          
_end:           NOP    

Quem programa em Python provavelmente já precisou fazer alguma coisa com threads. Contudo quando estamos trabalhando com PyQT há alguns incovenientes em utilizar as threads da API do Python, principalmente quando temos interfaces gráficas. Recentemente tive problemas para fazer uma função que executasse determinada ação após um tempo pré-definido em segundos. Pois quando enquanto a thread não terminasse sua execução a janela gráfica não aparecia.  Encontrei duas maneiras para solucionar,  a primeira utilizando QThread e uma muito mais simples usando QTimer,  fica o registro das duas maneiras:

from PyQt4 import *
from PyQt4.QtCore import *

class MyTimer(QThread):
	def __init__(self,parent = None):
		QThread.__init__(self,parent)

	def run(self):
		while 1:
		# a cada 'self.tempo' segundos o sinal é emitido e
                  nós tratamos na outra classe. Exemplo:
			self.emit(SIGNAL("sinal_atualiza()"))
			self.sleep(self.tempo)

	def Timer(self,t=5):
		self.tempo = t
		self.start()

Depois, na sua classe basta que gerencia a interface gráfica, basta instanciar o objeto e tratar os sinais definidos em MyTimer(), você pode definir quantos sinais forem necessários:

	  self.timer = MyTimer()
	  self.timer.Timer(3) # 3 segundos

	  self.connect(self.timer,
                       QtCore.SIGNAL("sinal_stualiza()"),
                       self.atualiza)
	  # caso seja necessario executar algo após o termino da
          # therad (não é o caso do exemplo acima que o while
          # "trava" na função run()
	  self.connect(self.timer,
                       QtCore.SIGNAL("finished()"),
                       self.finaliza)

Contudo existe uma maneira muito mais fácil de fazer um timer utilizando PyQT, usando a QTimer

	self.timer = QtCore.QTimer()

	self.connect(self.timer,
                     QtCore.SIGNAL("timeout()"),
                     self.atualiza)

        self.timer.start(3000) # tempo em milisegundos

Hoje tive uma idéia ao ler um artigo intitulado How Compiling Works no qual o autor descreve em linhas gerais, mas de uma maneira interessante, o processo de compilação de um código escrito em C (abordando  o processo de linkagem com as bibliotecas) tomando como exemplo a função printf. Resolvi fazer uma brincadeira, mostrando como isso pode ser realmente implementado na prática, usando chamadas de sistema (syscalls) do Linux, de modo que não seja necessário usar a implementação disponível na glibc.

Começando com um exemplo simples, bem parecido com que todo mundo que um dia pensou em programar já viu.  A diferença que a função printf será modificada para receber apenas caracteres (não variáveis) e a quantidade.

#include "stdio.h"
int main() {

	printf("Hello, world!\n",15);
	return 0;
}

Reparem que o cabeçalho está entre aspas, indicando ao compilador que vamos usar uma implementação particular e não a implementação da glibc, no meu caso os arquivos

• /usr/include/stdio.h (protótipo)
• /usr/lib/libc.so  (implementação)

Serão substituidos pelos arquivos stdio.h e stdio.c abaixo:

#ifndef STDIO_H_
#define STDIO_H_

int printf(char* texto, int tam);

#endif /* STDIO_H_ */

Agora que temos o protótipo da função printf() que é diferente da função printf() que conhecemos mas servirá para esse primeiro exemplo:

#include "stdio.h"

int printf(char* texto, int tam)

{
__asm__ ("movl $0x4,%%eax; \
          movl $0x1,%%ebx; \
          movl %0,%%ecx; \
          movl %1,%%edx; \
          int $0x80": : "g" (texto) , "g" (tam) );

  return 0;
}

Podemos incrementar um pouco mais do código em assembly, para não precisar estipular o número de caracteres.

__asm__ ("      xorl %%edx,%%edx; \
                xorl %%eax,%%eax; \

                movl %0,%%ecx; \
        loop:   movb (%%ecx,%%edx),%%al; \
                incl %%edx; \
                test %%al,%%al; \
                jnz loop; \
                decl %%edx; \

                movl $0x4,%%eax; \
                movl $0x1,%%ebx; \
                int $0x80": : "g" (texto));

Para fazer uma função equivalente ao printf() da glibc precisaríamos implementar o suporte a múltiplos argumentos e mais um monte de coisas Fiz um esboço de uma idéia do printf, mas ainda usando funções da glibc apenas implementando a syscall write.

#include <stdlib.h>
#include <stdarg.h>
#include <string.h>

#define _write(texto, d) 
__asm__ ("movl $0x4,%%eax; \
	  movl $0x1,%%ebx; \
	  movl %0,%%ecx; \
	  movl %1,%%edx; \

	  int $0x80": : "g" (texto) , "g" (d) );

int write(char *fmt, ...);

int main(){

	char *index=malloc(2);
	char *nome=malloc(20);

	strcpy(index,"19");
	strcpy(nome,"Escovando Bits !!!");

	write("blog: %s \nindex: %s\n",nome,index);

	return 0;
}

int write(char *fmt, ...) {

	char *s;
	va_list ap;
	register int d=0,tam;

	int size;

	va_start(ap, fmt );
	tam = strlen(fmt);

	for (d=0; d<tam; d++, *++fmt) {

		if (*fmt != '%' ) {

		_write(fmt,1);
		} else {

			switch (*++fmt) {
			case 's': {
				s = va_arg(ap, char *);

				size = strlen(s);
				_write(s,size);
			break;
			} // fim case
			} // fim switch

		} // fim else
	} // fim for

	va_end(ap);
	return(1);
}

Se analisarmos o código-fonte da glibc veremos que sua implementação é completamente diferente da proposta nesse post, por questões de portabilidade de hardware, segurança, elegância, desempenho, etc;  Um exemplo é a possiblidade de criar extensões para a função printf.

Bom, essa foi a primeira entrada do ano aqui no EscovandoBits,  mais novidades para os próximos dias, com a cobertura do Mauro sobre a Campus Party que acontece do dia 19 a 25 de Janeiro.

Posted in programação Tagged: c, glibc, kernel, Linux, syscalls ]]> http://escovandobits.wordpress.com/2009/01/21/exemplos-do-uso-syscalls-x86-do-linux/feed/ 0 Tiago Maluta http://escovandobits.wordpress.com/2008/08/05/convertendo-o-horario-do-portal-academico-da-unifei-para-o-google-calendar/ http://escovandobits.wordpress.com/2008/08/05/convertendo-o-horario-do-portal-academico-da-unifei-para-o-google-calendar/#comments Tue, 05 Aug 2008 05:59:49 +0000 Tiago Maluta http://escovandobits.wordpress.com/?p=128 ]]>

Na Universidade Federal de Itajubá os alunos de graduação e pós-graduação acessam o regristro acadêmico através do Portal Acadêmico. Dentre as opções, há como acessar o horário em curso. Este post apresenta um pequeno script para converter o horário apresentado na página do Portal Acadêmico no formato utilizado pelo Google Calendar

DOWNLOAD

.Update: A opção de importar do Google Calendar não está disponível já alguns dias, portanto não puder fazer mais testes, embora na última versão do código não tenha tido problemas. Se alguém conseguir, por favor, comente.

Observação

Eu fiz e testei esse programa em uma distribuição GNU/Linux (Ubuntu 8.04.1). Acredito que os usuários do Microsoft Windows não terão problemas em executá-lo, contudo problemas podem acontecer. Se houver algum reportem nos comentários ou por email (dentro do código-fonte há meu endereço).

Instalação

O programa utiliza a linguagem Python na sua versão 2.5. Além disso é preciso instalar alguns pacotes adicionais, se você estiver em alguma distribuição baseada no Debian, utilize:

# sudo apt-get install python2.5

# sudo apt-get install python-html5lib

# sudo apt-get install python-optcomplete

Faça o download do programa. Para ver as opções utilize o parametro -h.

# python pycalendar.py -h

Usage: pycalendar [options] FILE

Converts UNIFEI's grade from 'Portal Academico' to Google Calendar (iCal) or a
simple HTML table.

Options:
  --version   show program's version number and exit
  -h, --help  show this help message and exit
  -t, --html  Convert to a simple tabeled HTML file
  -i, --ical  Convert to iCal (Google Calendar format)
.

Como o Portal Academico possui um mecanismo de usuário/senha + CAPTCHA portanto é preciso logar no site através do navegador.

Após o login, acesse o MENU -> Registro Acadêmico GRADUAÇÃO -> Matrícula: Verificação/Confirmação.  Com a grade de horário aparencendo na tela, vá na opção File ou Arquivo no Firefox e escolha a opção Save Page As… (Salvar Página Como…).

Escolha um nome qualquer (se quiser deixe o padrão index.php.html).

Pronto!

Agora é só executar o programa:

Para gerar uma tabela no formato HTML, a saida será o arquivo chamado: “horario.html“:

# python pycalendar.py -t index.php.html

Para gerar uma tabela no formato do Google Calendar, a saida será o arquivo chamado “horario.ical”:

# python pycalendar.py -i index.php.html

Google Calendar

Preenchar os campos necessários, colocando o país e fuso horário da agenda:

Preenchendo os dados da nova agenda

Nas mesmas opções que você selecionou para criar uma nova agenda, marque agora a opção Importar Agenda, na Etapa1 selecione o arquivo horario.ical, na Etapa 2 escolha o horário na nova agenda e clique em “Importar”.

Importando os dados do pycalendar

Agora é só aproveitar o seu horário no Google Calendar

Conheço casos de amigos com notebooks novos, que depois de pouco tempo de uso (aprox. 1 ano) precisaram efetuar a troca da bateria pois esta não segurava mais carga alguma, dava uma autonomia de cerca de 15 minutos. Portanto recomendo duas medidas de prevenção.

1. Quando utilizar o computador ligado a rede elétrica, retire a bateria do notebook.
2. Pelo menos uma vez no mês, utilize a bateria até o fim e deixe uma noite inteira carregando.

Você tem alguma dica? Sugira aqui nos comentários.

Você pode monitorar seu sistema GNU/Linux obtendo as informações contidas na pasta /proc, um exemplo seria:

# cat /proc/acpi/battery/BAT1/info

present: yes
design capacity: 4000 mAh
last full capacity: 3719 mAh
battery technology: rechargeable
design voltage: 11100 mV
design capacity warning: 300 mAh
design capacity low: 148 mAh
capacity granularity 1: 32 mAh
capacity granularity 2: 32 mAh
model number: Chapala
serial number: 18850
battery type: LION
OEM info: SANYO

Um outro fator interessante é a capacidade de carga da bateria com o passar do tempo, de acordo com um amigo, quando comprou seu notebook, o last full capacity era de 3908 mAh. Estou fazendo os testes em um notebook LG R400. Para tal, resolvi fazer um pequeno programa em python para verificar a capacidade da bateria, é um programa simples que pega as informações da /proc referente a bateria e salva em um arquivo junto com o tempo atual do sistema. Agendando a execução com o cron pode-se após algum tempo obter um histórico dessa diminuição.

download aqui

..

A utilização é bem simples, executar sem nenhum parâmetro mostra a diferença entre a capacidade projetada e a última capacidade máxima. As outras opções são:

Usage: battery_analysis [options]

Veritfy the last full capacity of your battery

Options:
    --version     show program's version number and exit
    -h, --help    show this help message and exit
    -a, --all     show all contents of /proc/acpi/battery/<>/info
    -c, --colors  add colors in delta values

]]> http://escovandobits.wordpress.com/2008/05/04/dicas-para-economia-da-bateria-em-notebooks/feed/ 2 Tiago Maluta http://escovandobits.wordpress.com/2008/04/12/firefox-is-already-running-e-meu-primeiro-shell-script/ http://escovandobits.wordpress.com/2008/04/12/firefox-is-already-running-e-meu-primeiro-shell-script/#comments Sat, 12 Apr 2008 16:47:59 +0000 Mauro Rodrigues http://escovandobits.wordpress.com/?p=61 ]]>

Muitos usuários de sistemas que precisam logar em um servidor para obterem acesso ao localhost e a seus recursos/pastas pessoais provavelmente já se depararam, com a seguinte mensagem ao abrir o Firefox:

Firefox is already running, but is not responding [...]

(Firefox já está funcionando, mas não está respondendo [...])

Ai você pensa: “Firefox rodando? De forma alguma, acabei de me logar!”

Pois é, quando se é apenas usuário basta chamar alguém para resolver. Mas agora eu estou do lado da administração da rede, e tenho que solucionar esse tipo de imprevisto para os usuários frequentemente. E diga-se de passagem: Ô coisa chata de ser feita viu…

Bom juntando a necessidade de aprender Shell Script com a situação criei um script para corrigir esse problema do firefox, meu primeiro Script!!! Então leia mais!

Geralmente esse problema acontece quando usuários de sistemas que utilizam login em servidores, para disponibilizar as pastas pessoais via NFS, terminam abruptamente uma seção, devido a uma queda de energia ou reset, finalizando o Firefox de forma inesperada. Pode acontecer também do seu profile ter sido apagado, ou as permissões de acesso setadas equivocadamente; Nesses dois casos certifique-se se sua pasta profile ainda está no local correto e se está com permissões adequadas

Bom para resolver a situação basta remover um arquivo (oculto) do seu profile, chama-se parentlock o dito cujo! Ele serve para dizer que o profile já está em uso, evitando assim que haja uma inconsistência de dados caso o profile esteja sendo usado em modo compartilhado.

A Solução é simples, mas vai dizer para o usuário que ele precisa deletar o arquivo oculto, dentro da pasta oculta mozilla, dentro da home dele… Só se vê aquelas caras de: “Hein?! o.Ô”.

Então resolvi criar o script! Ele faz a remoção desse arquivo e em seguida abre o Firefox sem maiores problemas! O maior desafio nisso estava em chegar até a pasta do profile, pois ela possui nomes aleatórios seguindo o padrão:

XXXXXXXX.default [onde X pode ser qualquer letra, maiúscula ou minúscula, ou número].

Na hora pensei: Expressões regulares! Pois existe um arquivo em ~/.mozilla/firefox/ chamado profiles.ini que contém o nome da pasta que guarda o perfil do usuário. Mas pra quem ainda é iniciante, fica complicado… Não desisti!! Criei tempo, não sei da onde, e li boa parte de um livro de Shell! Aprendi o básico do uso de expressões regulares usando o sed e ed. O resultado você pode baixar clicando aqui: ressucita_firefox.sh

O arquivo está comentado, mas não custa deixar registrado aqui também:

sed ‘/Path=/!d’ ~/.mozilla/firefox/profiles.ini >temp1

A expressão acima deleta (d) todas as linhas que não contenham ‘Path=’ do arquivo profiles.ini e salva o que sobrar em temp1. Note que o uso da expressão não escreve no arquivo profiles.ini, portanto não se preocupe em fazer um backup prévio dele.

sed ’s/Path=//’ temp1 > temp2

A seguir, a expressão substitui (s) a primeira ocorrência de ‘Path=’, em temp1, por nada (//), salvando em temp2, onde teremos apenas o nome da pasta profile! Note também que fiz uso de 2 arquivos temporários (temp1 e temp2) pois uma propriedade do shell é que ao se direcionar o fluxo de dados para um arquivo, este será criado ou destruído, impedindo portanto coisas como:

sed ’s/Path=//’ temp1 > temp1

Finalmente a remoção:

rm ~/.mozilla/firefox/`cat temp2`/.parentlock

Repare que utilizei `cat temp2` no meio do arquivo afim de obter o endereço da pasta profile. Os acentos agudos, utilizados como apóstrofos, são imprescindíveis para o bom funcionamento pois indicam que a expressão dentro deles deve ser resolvida antes da expressão em geral (no caso rm). Assim temos na verdade a linha a seguir sendo utilizada:

rm ~/.mozilla/firefox/XXXXXXXX.default/.parentlock

E a remoção dos arquivos temporários criados:

rm temp1 temp2

Uma mensagem opcional:

echo “O Firefox sera iniciado em 3 segundos…”

E a execução do Firefox:

exec firefox

É simples, eu sei, mas muito útil, e poupa tempo! Agora basta disponibilizá-lo com um ícone do Firefox e pronto, o usuário nem notará a diferença! Não se esqueça de permitir a execução utilizando o chmod!

Fico por aqui, e aguardo qualquer tipo de sugestão de melhorias! Abraços!

]]> http://escovandobits.wordpress.com/2008/04/12/firefox-is-already-running-e-meu-primeiro-shell-script/feed/ 2 Mauro Rodrigues firefox_already_running http://escovandobits.wordpress.com/2008/04/09/analise-de-performance-da-linguagem-python-em-plataformas-x86-e-arm/ http://escovandobits.wordpress.com/2008/04/09/analise-de-performance-da-linguagem-python-em-plataformas-x86-e-arm/#comments Wed, 09 Apr 2008 22:53:35 +0000 Tiago Maluta http://escovandobits.wordpress.com/?p=57 ]]>

Este post apresenta um artigo, feito para a disciplina de Análise de Algoritmos, onde comparei a performance, utilizando a linguagem Python, de dois algoritmos de ordenação (bubble sort e quick sort) em duas plataformas, em outras palavras, no meu computador Intel Pentium 4 (x86) e no meu smartphone Nokia E62 (ARM). O texto traz os tempos gastos para ordenar vetores preenchidos com números aleatórios, de diferentes tamanhos. Tudo isso com a vantagem de poder utilizar o mesmo código-fonte (sem alteração alguma) para fazer os testes nos dois. É claro que perdi em performance não usando C ou C++, mas ganhei em portabilidade para pode fazer rapidamente esse teste. Se interessou, faça do download do pdf arm_vs_x86.pdf

Se você tem interesse em rodar o Python no seu smartphone (em especial os da Série 60 da Nokia) acesse: http://wiki.opensource.nokia.com/projects/PyS60

]]> http://escovandobits.wordpress.com/2008/04/09/analise-de-performance-da-linguagem-python-em-plataformas-x86-e-arm/feed/ 2 Tiago Maluta