Blog do Henrique

Notas Publicadas de Estruturas de Dados

2011-06-21T20:30:00.000-03:00

As notas foram publicadas. Quem não teve sua nota publicada deve procurar com urgência os órgãos competentes na FACIMA e descobrir porque seus nomes não parecem na minha listagem, que é o caso de alguns de vocês.

Ninguém será prejudicado, mas é dever de vocês verificar porque seus nomes não aparecem na minha lista (somente os que não aparecem, é claro). Tão logo esteja tudo resolvido, me avisem para eu publicar as notas.

Exames Finais de Sistemas Operacionais

2011-06-16T16:29:00.002-03:00

Mais sobre os exames finais.

O exame final de Estrutura de Dados será realmente na terça-feira, dia 28 de Junho, visto que foi decretado feriado no dia 27 na FACIMA, e em Alagoas em geral.

Exame Final: 28 de Junho, 19:15, sala de aula.

Os alunos de Sistemas Operacionais, turma da NOITE, que quiserem, podem fazer o exame final na TERÇA-FEIRA de noite, junto da turma de Estruturas de Dados.

As notas de Estruturas de Dados estão chegando ao site FACIMA agora, por favor alguns alunos confirmem que a nota está lá.

Para quem precisa fazer exame final de sistemas operacionais:

Turma da manhã: Dia 28 de Junho
Turma da Noite: Dia 30 de Junho (de noite, dããããã !).

Provas objetivas, de toda a matéria, com conteúdos balanceados, e que estão nas listas.

A média para passar é 5.0. Deve-se somar sua média, até agora, com a nota do exame, e dividir por 2. como é de praxe na FACIMA.

Até mais

P.S. Alguns de vocês confirmem por email que as notas estão aparecendo corretamente no site. Eu mesmo adicionei estas notas por volta de 15:30 até 16:30 do dia 16 de Junho.

main.c

2011-05-16T21:04:00.002-03:00

#include "lista.h"

int main(void)
{
Lista* L;
L = inicializa();
L = insere(L,12);
L = insere(L,8);
}

lista.h

2011-05-16T21:03:00.004-03:00

#include <stdio.h>
#include <stdlib.h>

struct lista
{
int n;
struct lista* prox;
};

typedef struct lista Lista;

Lista* inicializa(void);
Lista* insere(Lista* L, int v);

lista.c

2011-05-16T21:03:00.001-03:00

#include "lista.h"

Lista* inicializa(void)
{
return NULL;
}

Lista* insere(Lista* L, int v)
{
Lista* novo;
novo = malloc(sizeof(Lista));
novo->n = v;
novo->prox = L;
return novo;
}

provas finais de todas as disciplinas

2011-05-16T17:58:00.001-03:00

As provas finais (NP2) ocorrerão nos seguintes dias:

Estrutura de Dados NP2 dia 06/06/2011
Sistemas Distribuídos Último dia de AULA: 1/6
Sistemas operacionais, NOITE: NP2 dia 2/6
Sistemas Distribuídos MANHÃ: NP2 dia 7/6
Provas Substitutivas ocorrerão de 8/6 até 14/6
Exames, do dia 16/6 até 28/6

Fiquem atentos a estas datas.

Estruturas de Dados

2011-05-09T15:27:00.000-03:00

Nova lista de Estruturas de Dados.

Lista 8

Estrutura de Dados

2011-05-03T21:22:00.000-03:00

Conforme pedido por vocês, o livro em formato "livreto".

Para gerar um livro em formato livreto, pegue este documento, imprima em frente e verso, e corte ao meio. Ao longo da vertical, é claro (dãããã).

estrutura-livrinho.pdf

Alguém me avise por email que funcionou (ou seja, que está OK para imprimir). Como fazer ?

Instale um sistema operacional de verdade
na linha de comando, na pasta onde está o arquivo

pdf2ps arquivo.pdf arquivo.ps
psbook arquivo.ps | psnup -2 > novo.ps
ps2pdf novo.ps novo.pdf

novo.pdf é o arquivo em formato livreto.

Lista 7 de Estrutura de Dados

2011-04-25T18:36:00.000-03:00

A lista 7 não será entregue. Desta vez, faremos um mini-teste na próxima aula, nos 30 minutos finais, onde um pequeno pedaço de um dos programas da lista deverá ser reproduzido em aula.

Lista 7

Trabalho de Sistemas Distribuidos

2011-04-13T20:16:00.000-03:00

Trabalho em Grupo, três pessoas no máximo.

Trabalho

Sistemas Distribuidos

2011-04-06T11:41:00.001-03:00

Aos alunos

Infelizmente hoje não poderei dar aula de Sistemas Distribuidos. Desculpem pelo incomodo, e gostaria de pedir aos alunos da disciplina que receberam esta mensagem me avisem por email, e tentem repassar aos colegas para que estes não vão até lá somente para a minha aula.

Obrigado e desculpem de novo.

Listas de Estruturas de Dados

2011-03-21T18:55:00.000-03:00

Mais duas listas de Estruturas de Dados. Durante a aula definiremos as datas de entrega das listas.

Lista 5

Lista 6

Ainda temos a Lista 4 para ser entregue. A lista 4 está em Lista 4

Até mais

Sistemas Distribuidos

2011-03-16T19:25:00.000-03:00

Apostila de MPI (Programação Paralela)

Apostila MPI

Vamos construir alguns clusters na aula

http://www.open-mpi.org/

Página do google code com alguns códigos em C.

2011-03-03T14:27:00.001-03:00

Abri um projeto no google code para gerenciar os códigos em C, então estou enviando o link. Claro que para baixar programas, os mesmo vê-los (copiá-los) não precisa ter conta no google.

Se alguém quiser se cadastrar na página me mande um email, mas aí tem que ter conta no google (que não é o mesmo que ter conta no gmail, apesar da conta do gmail servir).

O link é

Google Code

Códigos em C - Página Inicial

Até mais

Lista 1 de Sistemas Operacionais

2011-03-01T22:50:00.001-03:00

Não são necessários, por enquanto, os problemas 5 até 17. Isto significa que alguns problemas poderão sair também, mas por enquanto são todos menos 5 até 17.

A Lista completa:

Todos os Problemas, à exceção de 5-17, 25, 27,28, 31-33, 46-53

Programas

2011-02-28T22:06:00.000-03:00

prog1 lista 4

#include <stdio.h>

int main(void)
{
int x[10];
int y[10];
// int x[10], y[10];
int i;
int tmp;
// int i, tmp;

for ( i = 0 ; i < 10 ; i++ )
{
printf("Digite valor");
scanf("%d", &tmp);
x[i] = tmp;
}

// for ( i = 0 ; i < 10 ; i++ )
// {
// printf("%d\n", x[i]);
// }

for ( i = 0 ; i < 10 ; i++ )
{
y[9-i] = x[i];
}

for ( i = 0 ; i < 10 ; i++ )
{
printf("%d\n", y[i]);
}

return 0;

}

prog3 lista 4

#include <stdio.h>
#include <stdlib.h>

int main(void)
{
int a[10];
int X;
// int x[10], y[10];
int i;
int tmp;
// int i, tmp;

for ( i = 0 ; i < 10 ; i++ )
{
printf("Digite valor");
scanf("%d", &tmp);
a[i] = tmp;
}

printf("Digite X");
scanf("%d", &X);

for ( i = 0 ; i < 10 ; i++ )
{
if ( X == a[i] )
{
printf("Achei %d no indice %d\n", X, i);
exit(0);
}
}
printf("Não\n");
}

Lista 4 de Programação em C

2011-02-28T19:09:00.002-03:00

Esta é a lista 4, que deverá ser entregue em data a combinar.

Lista 4

Trabalhos de Sistemas Distribuídos Entregues

2011-02-26T02:12:00.002-03:00

Entregaram os trabalhos os alunos:

Alexandre
Oscar
Gustavo
Zacarias

prog2.c

2011-02-23T20:53:00.000-03:00

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <complex.h>
#include <string.h>

#include <gsl/gsl_complex.h>
#include <gsl/gsl_complex_math.h>
#include <gsl/gsl_vector_complex.h>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_fft_complex.h>

int main(void)
{
int N = 1024;
int i;
double Tmin, Tmax, deltaT;
double f,A, B, w;
double t[N], g[N], l[N], h[N];

Tmin = -16.0; /* 16 vezes Pi */
Tmax = 16.0;
deltaT = 32.0/N;
f = 2.0;
A = 1.0;
B = 0.01;
w = 0.04;

for ( i = 0 ; i < N ; i++ )
{
t[i] = (Tmin + i*deltaT)*2.0*M_PI;
g[i] = A*sin(f*t[i]);
}

for ( i = 0 ; i < N ; i++ )
{
h[i] = B*sin(w*t[i]);
}

for ( i = 0 ; i < N ; i++ )
{
l[i] = h[i]*g[i];
}

for ( i = 0 ; i < N ; i++ )
{
printf("%f\t%f\n", t[i], l[i]);
}

/* Kmin = -1/2*deltaX */
// Fmin = -N/64.0;
// Fmax = N/64.0;
// deltaF = 1.0/32.0;

/* Gerar um seno, com uma dada frequencia (2Hz, por exemplo) */

}

prog1.c

2011-02-23T20:37:00.002-03:00

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <complex.h>
#include <string.h>

#include <gsl/gsl_complex.h>
#include <gsl/gsl_complex_math.h>
#include <gsl/gsl_vector_complex.h>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_errno.h>
#include <gsl/gsl_fft_complex.h>

int main(void)
{
int N = 1024;
int i;
double Tmin, Tmax, deltaT;
double f,A;
double t[N], g[N];

Tmin = -16.0; /* 16 vezes Pi */
Tmax = 16.0;
deltaT = 32.0/N;
f = 2.0;
A = 1.0;

for ( i = 0 ; i < N ; i++ )
{
t[i] = (Tmin + i*deltaT)*2.0*M_PI;
g[i] = A*sin(f*t[i]);
}

for ( i = 0 ; i < N ; i++ )
{
printf("%f\t%f\n", t[i], g[i]);
}

/* Kmin = -1/2*deltaX */
// Fmin = -N/64.0;
// Fmax = N/64.0;
// deltaF = 1.0/32.0;

/* Gerar um seno, com uma dada frequencia (2Hz, por exemplo) */

}

Programação em C - Verificador de números primos GRANDES

2011-02-23T14:16:00.002-03:00

#include <stdio.h>
#include <stdlib.h>

// Versão de números grandes de um verificador de números primos

int main(int argc, char* argv[])
{
unsigned long long int i;
unsigned long long int num = strtoull(argv[1], NULL, 10);

for ( i = 2 ; i < num ; i++ )
{
if ( num % i == 0 )
{
printf("num = %llu NÃO é primo\n", num);
exit(0);
}
}
printf("num = %llu é primo\n", num);
return 0;
}

// Compilar: gcc prog.c -o prog.exe
// Rodar: ./prog.exe numero
// Exemplo: ./prog.exe 71
// Saida : 71 é primo

Programação em C - Verificador de números primos

2011-02-23T14:13:00.001-03:00

#include <stdio.h>
#include <stdlib.h>

// Versão light de um verificador de números primos

int main(int argc, char* argv[])
{
int i;
int num = atoi(argv[1]);

for ( i = 2 ; i < num ; i++ )
{
if ( num % i == 0 )
{
printf("num = %d NÃO é primo\n", num);
exit(0);
}
}
printf("num = %d é primo\n", num);
return 0;
}

// Compilar: gcc prog.c -o prog.exe
// Rodar: ./prog.exe numero
// Exemplo: ./prog.exe 71
// Saida : 71 é primo

Programação em C - Lista 3, questão 3

2011-02-23T13:38:00.002-03:00

#include <stdio.h>

int main(void)
{
unsigned long long int num = 600851475143ULL;
unsigned long long int j;

for ( j = 3 ; j < num ; j++ )
{
if ( num % j == 0 )
{
num = num/j;
printf("%llu\t%llu\n", j, num);
}
}
printf("%llu\n", num);
return 0;
}

Programando em C

2011-02-17T02:36:00.001-02:00

Para começar a programar em C, basta ler o capítulo 1 da apostila que está no blog. Mas vou dar algumas explicações a mais, mas realmente ESTÁ NO LIVRO.

- Costumo digitar meus códigos num editor de texto comum, a famosa "folha em branco". Não pode ser editor tipo broffice, word, e afins. Tem que ser do estilo kate (que usei em aula), gedit, vim, emacs, notepad, wordpad, ou qualquer editor de código que você encontrar na internet. Neste momento inicial, NÃO RECOMENDO o uso de um IDE (ambiente de desenvolvimento). Visto que vocês teriam que aprender a programar e usar o IDE, o que é muito trabalho. Quem instala o Ubuntu, já tem o gedit instalado. Quem instala o Kubuntu, já tem o kate. Quem tem windows, uso o Notepad ou afins. Quem tem Mac, pode instalar o kate também, procure na internet.

- Costumo compilar meus programas na "linha de comando" usando o compilador gcc. Provavelmente este deve ser instalado. A instalação para Windows é horrível. Boa sorte. Para Linux, é bem mais fácil: vá no instalador de programas, procure por gcc, mande instalar. Só.

- Uma alternativa para windows é instalar um programa chamado dev-c++, que tem embutido um compilador (o próprio gcc) mais um editor simples. Podem usar também. Mas as provas serão feitas com o gcc, então tomem cuidado.

- É só isso que precisa. Vejam o vídeo exemplo. Vou começar do zero: criar uma pasta para guardar os programas, abrir o kate, digitar o programa, salvar. Ir para o terminal, entrar na pasta, compilar e rodar.

Veja o vídeo em resolução máxima e tela cheia. Não é muito grande, de qualquer modo.

Vídeos em formato maior:
ajuda_C_1.avi
ajuda_C_1.ogv

Material de Programação em C

2011-02-15T13:19:00.000-02:00

Este material introdutório é destinado a turma de sistema distribuídos e estruturas de dados.

O pessoal de sistemas distribuidos precisa entregar os problemas resolvidos por email até o dia 24 de Fevereiro, 23:59 da noite. Para sistemas distribuidos, só é necessário entregar a Lista 3. Quem quiser fazer as outras, principalmente a Lista 2, pode fazer.

O pessoal de Estruturas de Dados precisa entregar a Lista 1 no dia 28 de Fevereiro, até às 23:59, por email (henriquemarks@gmail.com).

Lista 1
Lista 2
Lista 3

Um bom material de C é este:

Apostila de C

Bom proveito a todos

Notas Finais

2010-12-09T13:37:00.002-02:00

Só vou publicar notas finais e/ou de exames quando tiver as notas de APS. Já tenho algumas, mas não posso publicá-las no sistema online. Aparentemente a secretaria deve fazê-lo. Tentei e não consegui.

Até mais

Notas Normalizadas de Sistemas Operacionais

2010-12-06T15:37:00.002-02:00

As notas, já normalizadas de Sistemas Operacionais Abertos, devem aparecer no site oficial hoje a noite. São as notas oficiais, já devidamente recalculadas por mim levando em conta os trabalhos.

Zacarias, acessei o sistema, tudo OK com teu trabalho, é 10 como os outros.

Até mais

CUIDADO: AO CONTRÁRIO DO QUE ESTÁ ESCRITO ACIMA, SUAS NOTAS NO SITE NÃO SÃO AS FINAIS AINDA, VISTO QUE AINDA NÃO TENHO AS NOTAS DA APS. ASSIM QUE EU TIVER, MODIFICAREI AS NOTAS CONFORME A NECESSIDADE.

Calculem suas médias conforme o blog, e verifiquem se precisam fazer o exame final.

Exemplo

2010-11-30T15:17:00.000-02:00

Alguém fictício tirou:

NP1 = 1.7
NP2 = 4.0
NT = 10
NTLinux = 0
APS = 0

Neste caso: NF = 0.3*(1.7 + 4.0 + 10) + 0.1*0 = 4.71
A pessoa terá que fazer exame final

Outro alguém fictício tirou

NP1 = 1.7
NP2 = 4.0
NT = 10
NTLinux = 0
APS = 10

Neste caso: NF = 0.3*(1.7 + 4.0 + 10) + 0.1*10 = 5.71
A pessoa está aprovada. Vou colocar esta nota no exame final, 5.7. Boas Férias.

Notas de Sistemas Operacionais Abertos

2010-11-30T15:09:00.000-02:00

Pegue sua calculadora e:

NP1 = Nota Prova 1
NP2 = Nota Prova 2
NTF = Nota Trabalho Final
NTLinux = Nota do Trabalho sobre Sistema de Arquivos Linux.

Nota_Final = 0.3 * ( NP1 + 0.1*NTLinux + NP2 + NTF) + 0.1*APS

Quem tirou mais que cinco, está de férias: repito a nota no exame final.

Quem tirou menos que cinco, exame final. Tem que tirar 5 para passar. O exame final é uma prova de toda a matéria.

P.S. Notem que o TrabalhoLinux está contando a mais, ou seja, quem o fez de maneira errada (tirou zero), não está sendo prejudicado por esse "engano". Já quem fez está ganhando um décimo a mais da nota.

P.S. 2 No boletim oficial, pareceram somente as provas normais, por uma questão burocrática. Mas eu garanto que a média final que aparecerá no seu boletim será a calculada por esta fórmula.

Até mais

Notas dos Trabalhos de Sistemas Operacionais Abertos

2010-11-29T18:09:00.002-02:00

Parabéns pelo excelente trabalho apresentado.

Tecnicamente, a turma demonstrou excelente desempenho. Falta ainda sair-se bem nas provas, onde o raciocínio lógico e analítico deve ser privilegiado. Creio que o pessoal precisa aprender a estudar, precisa aprender a buscar informações, acostumar-se a ler livros, materiais diversos. Adquirindo cultura de computação, vocês provavelmente melhorarão neste ponto. Mas este trabalho era técnico, e neste quesito quase todos sairam-se muito bem. Vejam que estas notas são extra oficiais, visto que no sistema eletrônico não posso colocar notas de trabalho, apenas NP1 NP2, etc.

Os seguintes grupos e componentes tiraram DEZ, a nota máxima, por terem mostrado o que foi exigido:

Joomla, integrantes Oscar e Alexandre
SugarCRM, integrantes Ewerton Henrique, Pedro Aurélio e Ítalo Rodrigo
OrangeHRM, integrantes Angélica Rodrigues, Ricardo Farias e Gustavo Souto
OpenSis, integrantes Tiago Feitosa da Silva, Ewerton Correia de Lira e João Paulo
OsCommerce, integrantes Eduardo Torres, Thiago Barros
Koha, integrantes Maurício Barros

Os seguintes alunos, que não cumpriram todos os objetivos, tiveram notas um pouco menores:

Marcos Vinícius e Thiago Amâncio, grupo Koha, nota 7.0 (sete)
José Zacarias, grupo Moodle, nota 7.0 (seis)

O aluno Jhonnes, do grupo OsCommerce, não compareceu, e está no momento sem nota.

Parabéns a todos, o coordenador do curso já foi informado das boas notas obtidas por vocês no TRABALHO. As considerações sobre o rendimento em provas, e minha visão dos problemas, também já foi informado. Espero realmente que as notas continuem aumentando na substitutiva, para quem fizer, e no exame final. As notas na NP2 podem ser vistas no portal do aluno, como sempre.

Prova 2 de PLC

2010-11-23T10:46:00.002-02:00

Solução prova 2 de PLC

2010-11-23T10:43:00.000-02:00

Problema 1:
mul $3, $2, $1
resultado: 418

Problema 2:

ori $1, $0, 0x01
sll $2, $1, 1
or $1, $2, $1
sll $2, $1, 2

or $1, $2, $1
sll $2, $1, 4
or $1, $2, $1
sll $2, $1, 8
or $1, $2, $1
sll $2, $1, 16
or $1, $2, $1

Problema 3:

li $8, 0x1000 # carrega o valor 0x1000 em $8

li $9, 1 # carrega o valor 1 em $9

loop:

addi $8, $8, 0x1000

addi $9, $9, 1

beq $9, 16, sai

j loop

sai:

Problema 4:

li $9, 0

li $10, 1

laco:

add $9, $9, $10

addi $10, $10, 1

j laco

Aula de PLC, sábado

2010-10-30T00:11:00.000-02:00

Estarei la às 8:00 da manhã, como foi marcado na segunda-feira, antes da aula de vocês, junto a secretaria dos professores, que marcou junto a direção. Foi confirmado o dia e horário na quarta-feira.

Estarei lá.

Lista de Exercícios de PLC

2010-10-29T19:39:00.000-02:00

A lista que entreguei em aula, apenas para constar no site

Aula de Projeto Lógico de Computadores neste Sábado (30/10)

2010-10-29T16:03:00.001-02:00

Começa as 8:00. Estarei esperando-os. Vamos fazer alguns problemas, e entregar mais uma lista de problemas.

Aula de sistemas operacionais abertos

2010-10-27T19:42:00.001-02:00

AULA EDITADA, CUIDADO, A AULA 9 NÃO ESTAVA COMPLETA. A 10 TAMBÉM NÃO ESTÁ, MAS NÃO CONSEGUIMOS TERMINAR EM AULA O ASSUNTO

Aula 8 de Sistemas Operacionais

2010-10-13T17:23:00.001-03:00

Trabalho final de Sistemas Operacionais Abertos - Grupos e Temas

2010-10-04T13:28:00.000-03:00

Grupos e Temas do Trabalho

OpenSis - Sistema de Gestão de Alunos

Ewerton Correia, Tiago Feitosa, João Paulo

osCommerce

Thiago Barros, Jhones, Eduardo Torres

Joomla

Alexandre di Salvo, Oscar Angeles

OrangeHRM

Angélica, Gustavo

Koha - Sistema de Bibliotecas

Tiago Amâncio, Maurício, Marcos

SugarCRM

Ewerton Henrique, Pedro, Ítalo

Até a próxima semana, entregarei a vocês uma primeira tarefa a ser entregue. Provavelmente uma especificação do que o sistema faz, ou uma apresentação de sua funcionalidade, ou a escrita de um manual de instalação, entre outras possibilidades.

Aula 7 de Sistemas Operacionais Abertos

2010-10-04T13:22:00.000-03:00

Projeto Lógico de Computadores - Aula 6

2010-09-29T10:29:00.000-03:00

Como (quase) ninguém entregou a lista, e o único motivo dela era associar a necessidade de estudar com a possibilidade de ganhar alguma nota facilmente, então a partir de agora vocês não precisam mais entregar as duas listas.

Algum aluno me pediu a segunda lista separada do livro, então está aí o link:

Lista 2 - Problemas 2-13 até 2-18

E a aula 6 a seguir.

Listas de Projeto Lógico de Computadores

2010-09-27T16:25:00.000-03:00

A lista 1 ficou para hoje, 27 de Setembro de 2010, no mesmo horário, às 19:00
A lista 2 ficou para o dia da prova, 04/10/10, e deve ser entregue até as 19:00.

Quem não puder enviar por email pode me entregar em mãos na FACIMA, sem problemas.

Daqui há pouco a próxima aula no site. Notem que a matéria das provas é o que vimos até agora, SEM CONTAR A AULA DE HOJE. Ou seja, a aula de hoje cairá na NP2.

Aula 6 de Sistemas Operacionais Abertos

2010-09-22T18:12:00.000-03:00

Aula 5 de Projeto Lógico de Computadores

2010-09-20T16:29:00.001-03:00

Aula 2 de Física Matemática

2010-09-20T14:43:00.000-03:00

Desculpem o atraso.

Trabalho Final da Disciplina de Sistemas Operacionais Abertos

2010-09-19T15:56:00.001-03:00

Definição dos Grupos

Alguns grupos já definiram seus assuntos e integrantes

Integrantes: Ewerton Correia, Tiago Feitosa e João Paulo
Assunto: Software-Livre de Gerenciamento de Informações Estudantis (SIS) - OpenSis

Integrantes: Thiago Barros, ...
Assunto: eCommerce, osCommerce

Integrantes: Alexandre di Salvo, Oscar Angeles
Assunto: CMS, Joomla

Integrantes: Ewerton Henrique, Pedro, Ítallo
Assunto: CMR (SugarCRM)

Trabalho 1 de Sistemas Operacionais Abertos

2010-09-19T15:12:00.000-03:00

Notas e Comentários

Apesar de repetidos avisos feitos por mim, alguns alunos copiaram seus trabalhos da internet. Quem copiou o trabalho, tirou zero, infelizmente. Um aluno, pelo menos, fez boa parte do trabalho, mas emprestou parte do seu trabalho a um colega, que copiou alguns textos e principalmente capturas de tela. Nota zero para ambos

Espero que nos próximos trabalhos isto não ocorra. Quem quiser discutir a nota do seu trabalho, pode conversar comigo as 19:00, na sala dos professores, na quarta-feira.

As notas finais serão calculadas assim:

(NP1 + NP2 +NTF +0.3*MT)/3.3 = MF

NP1 = Nota da Prova 1
NP1 = Nota da Prova 2
NTF = Nota do Trabalho Final
MT = Média dos Trabalhos
MF = É a média final, arredondada para cima, se necessário.

Ou seja, este trabalho mais alguns outros contarão como 30% de uma prova.

Nome	NP1	NP2	NTF	NT1	MT	MF
Pedro Aurélio	NP1	NP2	NTF	zero(b)	MT	MF
Gustavo Souto	NP1	NP2	NTF	5,0	MT	MF
Marcos Vinicius	NP1	NP2	NTF	zero(a)	MT	MF
Alexandre Di Salvo	NP1	NP2	NTF	10,0	MT	MF
Ewerton Henrique	NP1	NP2	NTF	7,0	MT	MF
João Paulo	NP1	NP2	NTF	zero(c)	MT	MF
Angélica Ferreira	NP1	NP2	NTF	zero(d)	MT	MF
Cliviane Pereira	NP1	NP2	NTF	zero(e)	MT	MF
Ítalo Rodrigo	NP1	NP2	NTF	zero(f)	MT	MF
Oscar Angeles	NP1	NP2	NTF	9,5	MT	MF
Nome	NP1	NP2	NTF	NT1	MT	MF
Nome	NP1	NP2	NTF	NT1	MT	MF
Nome	NP1	NP2	NTF	NT1	MT	MF
Nome	NP1	NP2	NTF	NT1	MT	MF
Nome	NP1	NP2	NTF	NT1	MT	MF

(a) Cópia de http://www.guiadohardware.net/artigos/algumas-peculiaridades-linux/ e http://www.gdhpress.com.br/linux/leia/index.php?p=cap1-14 . Capturas de tela copiadas de/para um colega (atente para o link do pen-drive nas capturas).

(b) Deu as capturas de tela para outro colega, ou emprestou dele. Cópia de http://www.guiadohardware.net/dicas/linux-entendendo-arvore-diretorios.html. Escreveu parte do trabalho, mas as capturas de tela copiadas/emprestadas me OBRIGAM a dar esta nota.

(c) Cópia de http://www.explorando.viamep.com/2006/05/linux-entenda-estrutura-de-pastas-e.

(d) Cópia de http://www.guiadohardware.net/dicas/linux-entendendo-arvore-diretorios.html e http://www.icefusion.com.br/curriculo/67-estrutura-basica-de-diretorios-do-linux

(e) Cópia de http://0fx66.com/blog/linux/entendendo-as-estruturas-de-diretorios-no-linux/

(f) Cópia de http://ademirlord.blogspot.com/2010/02/comandos-e-diretorios-no-linux.html

Aula 4 de Java II

2010-09-17T08:44:00.001-03:00

Nosso tutorial de sempre, somente repetindo o link

Trabalho da disciplina.

Fazer os programas a seguir, retirados da lista de exemplos da página da Oracle. Os programas devem ser feitos utilizando o editor visual do Netbeans, ou seja, os exemplos devem ser adaptados para usar o editor visual.

Os exemplos que devem ser feitos são:

Entrega dia 07/10/2010, no dia anterior ao da Primeira Prova da Disciplina. A matéria da primeira prova é exatamente esses programas.

Entrega por email, para henriquemarks@gmail.com, contendo

Um arquivo zipado, contendo todos os códigos separados por PASTAS. Ou seja, cada Projeto numa pasta separada. O nome do arquivo zipado deve ser seunome.
O Título do email deverá conter:

SEUNOME-JAVA2-TRABALHO1
O Trabalho anexado

A entrega deve ser feita até as 21:00 do dia 07/10/2010, por email.

Aula 5 de Sistemas Operacionais Abertos

2010-09-15T17:44:00.001-03:00

Faremos a definição dos trabalhos de final de curso desta disciplina.

Tenho várias sugestões de projetos, provavelmente este trabalho servirá não somente para esta disciplina, mas também para os seus futuros TCCs, para quem se interessar, e também para dar os primeiros passos numa carreira profissional empreendedora. Sugiro fortemente que as pessoas cheguem no horário da aula, hoje, as 19:15.

Minhas sugestões de Trabalhos até o momento

Trabalho em grupo, com apresentação no final do curso. Grupos de no máximo 3 pessoas.
Vale uma nota de uma prova, ou seja, trabalho final + prova 1 + prova 2 + peso*(outros trabalhos) comporão a nota toda.

ASSUNTOS

Softwares-Livre de Gerenciamento de Projeto

Candidatos: OpenGoo, eGroupWare, dotProject, Redmine

Softwares-Livre de Gerenciamento de Recursos Humanos (HRM)

Candidatos: OrangeHRM

Softwares-Livre para gerenciamento de conteúdo Web (CMS)

Candidatos: Drupal, Joomla!, Plone

Softwares-Livre para Gerencia de Relacionamento com Clientes (CRM)

Candidatos: Sugar, OpenERP

Softwares-Livre para Comércio Eletrônico (eCommerce)

Candidatos osCommerce, Magento

Softwares-Livre de gerenciamento de bibliotecas

Candidatos: openBiblio, Koha

Softwares-Livre de Gerenciamento de Informações Estudantis (SIS)

Candidatos: openSIS

Softwares-Livre para Educação a Distância (EAD)

Candidatos: Moodle

Softwares-Livre para Gestão de Empresas (ERP)

openERP, openBravo

Iremos vasculhar todos estes na aula, e colocaremos os links principais dos projetos assim que eles forem definidos.

Aula 4 de Projeto Lógico de Computadores - Cont.

2010-09-14T10:58:00.001-03:00

Aula 1 de Física Matemática I

2010-09-14T10:58:00.000-03:00

Aula 4 de Sistemas Operacionais Abertos

2010-09-08T16:17:00.001-03:00

Processos

Introdução

Os processos contém, além do código de execução (text section), os recursos usados (como arquivos abertos), sinais, dados internos do kernel, um espaço de endereços na memória, e uma seção de dados (data section), contendo variáveis globais.

Um processo pode conter várias threads de execução (threads). no Linux, um thread é um processo especial, de modo que o tratamento de threads é o mesmo de processos.

Um processo inicia no Linux através da chamada de sistema fork(), que cria um processo duplicando outro. O kernel retorna duas vezes de fork(): uma vez para o processo que chamou fork (o processo pai) e outra vez para o processo que foi criado (o processo filho).

Em geral, o processo filho chama uma das funções da família exec() para criar um novo espaço de memória e susbtituir a existente, de modo que o filho realmente distingue-se do pai.

Em versões recentes do kernel, a chamada a fork() é implementada por uma chamada a clone(), que atrasa o processo de duplicação do processo pai inteiro, visto que este poderá (ou não) ser substituído pelo filho. Veremos esta implementação do kernel com mais detalhes.

Processos no Kernel

O kernel mantém a lista de processos numa lista circular duplamente encadeada chamada task list

Cada elemento da lista é chamdo descritor de processo, e é do tipo struct task_struct.

Esta estrutura está definida num arquivo de cabeçalho, em <linux/sched.h>

Definição de task_struct

Lista de Processos e cada descritor de processos, contendo a struct task_struct

Guardando o descritor de processo

Cada processo tem associado a si um ID, chamado PID, que é um tipo pid_t, que é muitas vezes um sinônimo para int, ou, por questões de compatibilidade short int (16 bits). Pode-se modificar o valor em tempo de execução em /proc/sys/kernel/pid_max.

No kernel,. os processos são referenciados pelo endereço de memória (ponteiro) de sua task_struct. Cada processo tem uma, e ela está em alguma posição de memória. Existe uma macro que guarda este ponteiro, chamada current, que contém o endereço do processo EM EXECUÇÃO.

No PowerPC, este endereço está num registrador.

No x86, este endereço está na região de memória do processo, em geral na mesma posição relativa, possibilitando que um código em linguagem de montagem recupere este valor rapidamente.

Estados dos Processos

A task_struct contém um campo state, que pode ter os seguintes valores:

volatile long state; /* -1 unrunnable, 0 runnable, >0 stopped */

As possibilidades para os processos (tasks) rodando são:

TASK_RUNNING: O processo pode rodar, ou está rodando, ou está numa runqueue (fila de execução.

TASK_INTERRUPTIBLE: O processo está "dormindo", esperando para ser posto em execução novamente.

TASK_UNINTERRUPTIBLE: O mesmo, mas o processo NÃO responde ao envio de sinais (que é um dos mecanismos de comunicação entre-processos visto em Sistemas Operacionais).

Manipulando o estado atual do processo

set_task_state(task, state). Ajusta a tarefa (processo) task para estar no estado state.

Aula 3 de Sistemas Operacionais Abertos

2010-09-08T16:08:00.002-03:00

Livro do Robert Love, LKD, capítulo 2

Obtendo o código-fonte do Kernel Linux

Usando git

Não é a maneira mais fácil, e deve ser usada apenas por aqueles que querem acompanhar as modificações, ou trabalhar na fronteira do desenvolvimento. É a versão de hoje do kernel. CUIDADO COM FIREWALLS MAL CONFIGURADOS.
$ git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git

Código-fonte da sua distribuição.

É o método recomendado para nós
Ubuntu 10.04: kernel 2.6.32.XX, onde XX depende do quão atualizado está o seu sistema.
Instale o pacote linux-source.
Um arquivo zipado (.bz2) será colocado na pasta /usr/src/ , chamado linux-source.tar.bz2. Copie este arquivo para a sua pasta pessoal (o seu home) e descompacte-o. Será criada uma pasta linux-source

A árvore do Kernel e suas pastas.

O kernel contém muitas pastas. Algumas delas serão vistas aqui, verifique as outras no livro.

Pasta Descrição

arch Código dependente da arquitetura (x86, ARM, MIPS,...)

Documentation Documentação

drivers Drivers em geral (a maior pasta)

include Kernel headers, arquivos .h do kernel, veja manual de C.

init inicialização do kernel

kernel subsistemas principais

mm gerenciamento de memória

net subsistema de rede

Compilando o Kernel

Antes de compilar o kernel, precisamos configurá-lo. Queremos o suporte a funcionalidade de gerencia de memória A ou B ? Queremos o driver de placa de áudio X ou Y ? Podemos configurar estas opções antes de compilar o kernel. Há ferramentas que ajudam nesta compilação.

Por exemplo, digitando o comando (na pasta onde você colocou o kernel, já descompactado)

make menuconfig

É oferecido a você um menu de opções de configuração do kernel, que você pode navegar facilmente, escolhendo as opções que mais lhe agradam.

Se você não sabe nada, e está apenas começando, pode gerar uma configuração default (padrão) para a sua plataforma, que será detectada automaticamente, usando o comando:

make defconfig

Este comando cria a configuração padrão. Esta configuração é guardada num arquivo chamado .config (note que arquivos começando por . no Linux são ocultos. Para vê-los, va no menu do gerenciador de arquivos e marque ver arquivos ocultos). Você pode editar esta configuração diretamente neste arquivo texto, e salvá-lo com este nome. Após, rode o comando:

make oldconfig

Para que o arquivo editado a mão por você seja interpretado e validado. Está configurado o kernel, pronto para compilação, usando o comando:

make

Vá tomar um chá, café ou chimarrão enquanto espera.

Instale o kernel

Em x86, com grub2, você precisa copiar ua imagem do kernel recém-compilado para uma pasta do sistema, editar o arquivo de configuração do grub (o bootloader, programa que faz a inicialização), colocando as informações do seu kernel lá.

Tarefa: Compile o kernel no seu computador, na sua casa.

Trabalho 1 de sistemas Operacionais Abertos

2010-09-08T14:14:00.000-03:00

Trabalho 1:

Entrega: 15/09/2010, até as 19:00, por email, para henriquemarks@gmail.com

Formato: PDF

Assunto: Faça uma pesquisa sobre a estrutura de diretórios utilizada nas distribuições Linux em geral, explicando a estrutura e as pastas, a utilidade de cada uma, permissões, detalhes, e outras questões que você achar relevantes. Exemplifique o seu trabalho com capturas de tela do seu próprio sistema.

O trabalho deve conter Título, Autor, Instituição, Data, Resumo, Introdução, Seções e Subseções, Conclusão e Referências.

Para quem quer começar a fazer bons trabalhos, utilizando um bom editor de texto científico, eu sugiro o uso do editor lyx, no Linux ou Windows. É um editor gráfico de Latex, e para quem quiser usar, basta abrir o lyx e criar todos esses itens de formatação que estão acima. Depois, é só escrever no meio do texto. Há manuais de ajuda disponíveis no programa, um tutorial excelente, e algumas dicas que darei em aula. Há ainda alguns templates (modelos) prontos, bastando preencher com o seu trabalho os espaços em branco.

Aula 4 Projeto Lógico de Computadores

2010-09-06T13:35:00.000-03:00

Operandos imediatos ou constantes

Existe uma instrução especial para adicionar valores constantes. Por que ? Porque esta operação é muito comum.

Como somar uma constante a um valor ?

Constante = 4 . Onde ela está na memória ? Em $s1 + addr , por exemplo.

Logo:

lw $t0, addr($s1)
add $s3, $s3, $t0

Duas instruções para carregar um valor constante da memória num registrador e depois somar com outro valor. MUITO DISPENDIOSO.

Instrução Adicionar Imediatamente

addi $s3, $s3, 4

Princípio de Design 3

Faça com que as operações mais comuns sejam rápidas

Existe ainda no MIPS um registrador que contém zero, sempre, chamado $zero

Não existe subi no MIPS, porque pode-se utilizar diretamente constantes negativas no MIPS.

Aula 3 Projeto Lógico de Computadores

2010-09-04T16:03:00.038-03:00

Estamos seguindo fielmente o capítulo 2 de Patterson e Hennesy, e vocês já podem começar a usar o simulador Mars e ou SPIM. O Mars você obtém da Internet ou

Mars.jar

Eu extraí o arquivo, criando uma pasta Mars. Para rodar o simulador, eu entro na pasta pela linha de comando:

cd Mars (cuidado com a maiúscula)

e depois digito:

java Mars

O spim você instala normalmente.

O Livro, desculpem pelo tamanho:

Computer Organization and Design 4thEd. Patterson and Hennessy

A aula

2.1 Introdução

Para trabalhar com computadores devemos entender sua linguagem.
A linguagem de um computador é o conjunto de instruções que ele entende (instruction set).
Vamos trabalhar com um conjunto de instruções real, da família de processadores MIPS.
Mips é RISC, ou seja, é um computador que entende um conjunto reduzido de instruções (reduced instruction set computation)
Temos também CISC, conjunto complexo de instruções
Desde o início da computação moderna, sabia-se que um conjunto reduzido de instruções seria capaz de realizar qualquer computação

Conceito de Programa Armazenado:

Vamos representar os dados por números no computador.
Vamos representar as instruções por números no computador.

Por que MIPS ?

É usado em sistemas embarcados
É RISC
É parecido com ARM
Temos Simuladores (Mars, SPIM).

2.2 Operações de Hardware do Computador

Todo computador deve ser capaz de realizar operações aritméticas básicas.

Ex: (todos os exemplos no MIPS)
add a,b,c

adicionar "b" e "c" e colocar em "a"

Operações aritméticas no MIPS: Uma operação por vez, três operandos.

Ex: Somar "b", "c", "d" e "e" em "a"

add a,b,c
add a,a,d
add a,a,e

O MIPS tem 32 registradores e 2^30 palavras de memória (2 elevado na trinta, ou seja, 1 Giga palavras na memória). e isto leva ao princípio de Design 1.

Simplicidade favorece a regularidade

Ou seja, operações simples, que são sempre iguais, são mais fáceis de implementar em Hardware.

Ex: Linguagem C

a = b + c;
d = a - e;

Qual é o código assembly correspondente ? Ou seja, qual seria o código gerado por um compilador a partir deste código C ?

add a,b,c
sub d,a,e

Operação sub, de subtração

Ex: Linguagem C

f = (g + h) - (i + j);

Qual é o código de montagem (assembly) gerado ?

add t0, g, h
add t1, i, j
sub f, t0, t1

2.3 Operandos do Hardware do Computador

Operandos aritméticos

Os operandos das operações aritméticas devem estar armazenados nos registradores da CPU
Tamanho de um registrador no MIPS: 32 bits
Grupos de 32 bits = palavra (word)

Por que 32 registradores ?

Resposta 1)

Príncipio de Design 2

Menor é mais rápido

Ou seja, menos registradores, significa Hardware mais simples e mais rápido. O ciclo de relógio pode ser menor com menos registradores.

Resposta 2)

Tamanho de instruções e endereçamento (seção 2.5)

Convenção para escrita de registradores: Símbolo $, seguido de dois caracteres

Ex: Escreva usando os registradores

f = (g+h) - (i+j);

Resposta:

add $t0, $s1, $s2
add $t1, $s3, $s4
sub $s0, $t0, $t1

Operandos de memória

As linguagens de programação tem , em geral:

variáveis
vetores
estruturas

Como guardar estes tipos complexos nos registradores, para realizar operações neles ?

Registradores: São poucos, com pouco espaço
Memória: Muita!

Temos que ser capazes de transferir dados da memória para os registradores, e vice-versa

Instruções de transferência de dados

Para acessar uma palavra na memória, a instrução deve fornecer um endereço.

E endereço do terceiro elemento é 8, e o seu valor é 10 (memory[2])

Instruções load word(lw) e store word(sw)
Carregar da memória (lw) e guardar na memória (sw)
A primeira das instruções traz da memória e coloca num registrador
A segunda instrução pega o valor de um registrador e coloca na memória

Formato da instrução

Nome da instrução (lw) seguido do registrador onde colocaremos o valor, e depois uma constante e mais um registrador contendo um endereço

Ex: Linguagem C

A é um vetor com 100 palavras (A[100]), cujo endereço inicial está armazenado em $s3
g e h são duas variáveis: {g,h} --> {$s1, $s2}
g = h + A[8];

Qual é o código de montagem correspondente ?

Carregar da memória o valor num registrador temporário
lw $t0, 32($s3)

lw é a instrução para carregar da memória no registrador
$t0 é o nome do registrador
Qual é o endereço de memória ? 32($s3)
$s3 é o endereço inicial do vetor (por exemplo, endereço 80)
32 significa o deslocamento (em bytes) em relação a posição inicial (por exemplo, 80 + 32 = 112)
Por que 32 ? 32 = 8 * 4. O primeiro elemento de A está em 80. O segundo está 4 bytes adiante, ou seja, 84, o terceiro em 88, e assim por diante. Logo, o elemento A[8] esta na posição $s3 + 8 * 4.
No MIPS, existe restrição de alinhamento de memória, ou seja, todas as palavras devem inciar em posições de memória que são múltiplos de 4.

$s3 é chamado de endereço base (registrador base)
32 = 8 * 4 é chamado de deslocamento (offset)
Após carregar em $t0 o valor de A[8], somar com h e colocar em g

$s1 = $s2 + $t0

A operação oposta de load word é store word, que pega o valor em um registrador e coloca num endereço de memória

Ex: Linguagem C

h --> $s2
endereço inicial de A --> $s3
A[12] = h + A[8];

Resposta

Carregar A[8]

lw $t0, 32($s3)

Somar com h e guardar num local temporário

add $t0, $s2, $t0

Guardar na memória, no elemento 12 do vetor A.

sw $t0, 48($s3)
Guardar o valor de $t0 no endereço $s3 + 48, ou seja, no elemento 12 de A (12*4)

Sistemas Operacionais Abertos

2010-09-04T15:20:00.000-03:00

Nossos manuais para sistemas operacionais abertos e o Kernel:

Principal, mais voltada a código, e mais recente
Linux.Kernel.Development.3rd.Edition

Secundária, mais voltada a sistemas operacionais em geral
Understanding The Linux Kernel 3rd Edition

No Linux, talvez seja necessário instalar um visualizador de arquivos chm, como o kchmviewer.

Aula 2 Java - FACIMA

2010-09-02T16:41:00.000-03:00

Nesta aula, continuaremos seguindo os tutoriais do site da Oracle sobre Swing e Java, e usaremos uma ferramenta de gerência de código-fonte para manter os códigos num repositório.

Faremos uma recapitulação sobre o uso do Netbeans, e um programa simples, conforme o post anterior sobre a aula de Java.

Depois, seguiremos um exemplo no Swing Tutorial, para criarmos um aplicativo gráfico simples.

Criando um Aplicativo gráfico

Disciplina Java - FACIMA - 2010/2

2010-09-02T14:20:00.000-03:00

Já temos um repositório de código-fonte, ou seja, um local onde os códigos de vocês ficarão armazenados, para facilitar o trabalho de vocês individualmente e em equipe.

O projeto está hospedado no code.google.com, e o link é:

Repositório do Google para nossos projetos

O nome do projeto é facima-java-20102, e vocês DEVEM pedir autorização para mim para ingressar no grupo, por email.

No título do email, por favor, coloque:

FACIMA-JAVA-20102

Coloque seu nome completo no corpo do email, por favor.

Cadastrarei e retornarei o mais rápido possível.

Até mais

Instrução disciplina de Java

2010-09-02T14:06:00.000-03:00

Para instalar TUDO o que é necessário para trabalharmos, no momento, basta, no Linux:

- Abrir o instalador de programas
- Instalar o netbeans

Todo o resto que é necessário será instalado junto, automaticamente.

Em outras plataformas, você precisa baixar do site da SUN/ORACLE, e instalar tudo a mão. No Linux, não precisa nada disso, somente siga as instruções acima.

Vamos usar algumas ferramentas de gerenciamento de código-fonte, então eu sugiro que instalem também o pacote subversion no Linux, ou o programa Tortoise no Windows.

Aula 3 de Projeto Lógico de Computadores

2010-08-30T15:16:00.007-03:00

Fonte: Livro de D.A. Patterson, e J.L. Hennessy, Computer Organization and Design, 4ed

2.1 - Introdução

2.2 - Operações do Hardware do Computador

2.3 - Operandos do Hardware do Computador

Lista de Exercícios

Os exercícios devem ser entregues individualmente, até o dia 20/07/2010, as 11:59 da manhã, por email para o prof. Henrique Marks. O email deve conter no título:

FACIMA - PLC - Trabalho X
onde X é o número do trabalho, PLC é a nossa disciplina.

Meu email é henriquemarks@gmail.com

Lista 1 - PLC - 2010

O trabalho/lista consiste em fazer os exercícios 2.1 até 2.12.

Aula 2 de Sistemas Operacionais Abertos

2010-08-30T12:09:00.000-03:00

Vimos alguns comandos na aula 2, principalmente aqueles relativos a visualização de processos no Linux. Vamos ver mais alguns comandos nas outras aulas.

A interface de linha de comando é bastante poderosa para realizar tarefas automatizadas, ou realizar a mesma tarefa para múltiplos usuários. Por exemplo, você poderia ter um sistema com 100 usuários e gostaria de trocar o nome de uma pasta qualquer, dentro da pasta de dados de cada usuário.

É claro que você poderia ir ao gerenciador de arquivos e fazer isto, para cada usuário, mas seria uma tarefa monótona e extremamente demorada. Se fossem mil usuários, seria impossível fazer usando uma interface "point-and-click". Nesta hora a linha de comando torna-se poderosa.

Você precisa saber comandos para usar Linux ? Quase certamente NÃO. Esta idéia antiquada ainda permanece, mas não é mais verdadeira.

Se você tiver problemas com suporte a algum hardware, precisará usar linha de comando no Linux ? Quase certamente SIM. Porque você irá procurar informações na internet (tal aparelho funciona no Ubuntu XX.X ?) e as respostas serão fornecidas iniciando com a frase "abra um terminal e digite". Isto é um pouco intimidador, mas não esqueça que para usuários comuns, qualquer problema com Hardware é intimidador, em qualquer SO. A vantagem de receber instruções pela linha de comando é que, em geral, você copia e cola as instruções no terminal, e as coisas funcionam.

Se você trabalha com informática, você precisa saber comandos ? Claro que SIM. Afinal de contas, os profissionais devem conhecer uma das maneiras de trabalhar com o sistema. Se você não aprender, não será tão qualificado quanto outros que aprenderam, simples assim.

Os comandos tornam-se especialmente úteis nos seguintes dois casos:

Tarefas de Gerenciamento de Sistemas.
Tarefas de instalação de servidores diversos.

Note que estas tarefas são executadas por profissionais, não sendo necessárias no dia-a-dia.

Dois comandos que vimos na aula são ps e top. O primeiro mostra informações de processo, e ose gundo também mas de uma forma mais dinâmica. Tão importante quanto os comandos, é saber que estes programas contém opções e uma página de manual instalada no seu sistema. Se você abrir um terminal e digitar (não precisa digitar $, é só para indicar que estou na "linha de comando"

$ man ps

Será aberta a página de manual do comando ps. Para correr uma folha, pressione a barra de espaço, para sair aperte q. Veja a figura:

Captura de Tela da página de manual do comando ps.

A página de manual mostra qual é o comando, mostra que este comando tem opções, mostra alguns exemplos (teste TODOS no seu computador), e prove algumas explicações. Muitas vezes estas páginas estão traduzidas. Não esqueça: a barra de espaço vai para a outra página, q sai, b volta, etc.

É possível visualizar estas páginas de uma forma mais bonita. Usando o programa konqueror (se não estiver isntalado, pode fazê-lo pelo instalador de programas), que é um navegador Web, gerenciador de arquivos, visualizador, etc. pode-se ver a mesma página de manual digitando na barra de endereço

man:ps

Veja a figura como fica

Visualização do comando ps no konqueror

Para os outros comandos, valem as mesmas instruções. É sempre a mesma sintaxe: (comandos opções). E a página de manual está em man comando, na linha de comando, ou man:comando, no konqueror.

Aula 2 de Sistemas Operacionais Abertos

2010-08-30T11:47:00.000-03:00

Nosso livro teórico da disciplina é o livro de Sistemas Operacionais do Tanembaum. Podem usar a segunda ou terceira edição, sem nenhum problema, visto que as diferenças entre elas sao mínimas, para o nosso uso.

Nossa referência de linguagem C já passei num outro post do blog, e a referência para o kernel Linux será o livro

Linux Kernel Development, 3ed, 2010

Está em inglês, o que é normal visto que o livro é de Junho de 2010.

Aula 2 de Projeto Lógico de Computadores

2010-08-29T23:54:00.001-03:00

Visão Geral do Funcionamento de um Computador

Máquina de von Neumann/Turing:

Conceito de programa guardado dentro do computador.
Dentro da memória, são guardados os dados e as instruções para operar sobre estes dados.
Unidade aritmética e lógica realizações essas operações.
Unidade de controle interpreta as instruções da memória e as executa
Entrada e Saída operada pela unidade de controle

Esta figura está em W. Stallings, Computer Organization and Architecture, ed. 6, pag.18, cap2

Na figura, podemos ver as partes principais do computador, numa figura de nível bem baixo. A Unidade de controle e aritmética interagem com a memória principal, e entre si. CREIO que a figura tem um ERRO, visto que é a unidade de controle que faz E/S, e não a unidade aritmética. Passei esta figura em aula e não percebi o suposto erro, ou interpretei mal. Minha interpretação é que esta errada a figura. Mas continua válida a interpretação desta, de qualquer modo.

Vimos também o ciclo de execução de um programa, e as partes do computador numa visão "mais próxima". Nesta vião, mostrada na figura seguinte, temos a CPU, composta das unidades de controle e aritmética/lógica e alguns registradores na CPU. Estes são posições de memória utilizadas para guardar certas informações, e a quantidade e a funcionalidade destes definem todo o funcionamento do processador, ou o projeto lógico da CPU. Comunicando-se com a CPU temos a memória principal e algum dispositivo de entrada e saída.

As partes do computador. Figura de W. Stallings, Computer Organization and Architecture, ed. 6, pag.53, cap3

Os registradores tem nomes, conforme seu uso. Por exemplo, nesta figura temos:

Contador de Programa (PC). É usado para guardar qual instrução está sendo executada num dado instante.
Registrador de instrução. Guarda a instrução que foi buscada da memória e que será executada.
MAR/MBR: Registradores para guardar endereços de memória
IO/AR,IO/BR: Registradores para guardar endereços de Entrada/Saída

Na memória, podemos verificar que guardamos tanto DADOS quanto INSTRUÇÕES. Estas instruções especificam como aCPU irá operar nos próprios dados que ali também estão.

Um computador terá um ciclo de execução, que será repetido a exaustão. De uma maneira simplificada, o ciclo de execução mais simples é aquele que contém dus partes. Uma parte é a de busca (de instruções e/ou dados) e outra de execução da instrução buscada. A figura abaixo mostra este ciclo.

O ciclo de execução mais básico (fetch cycle = ciclo de busca, execute cycle = ciclo de execução). Figura de W. Stallings, Computer Organization and Architecture, ed. 6, pag.54, cap3

Vamos dar um exemplo de um programa rodando num sistema simplificado. Nosso sistema pode acumular (somar) valores inteiros, que devem ser trazidos da memória. Além disso, nosso sistema é de 16 bits, ou seja, os registradores são de 16 bits, e a memória é dividida em pedaços de 16 bits. É importante entender que no endereço x, temos 16 bits, e no endereço x+1, mais 16 bits (em geral, as memórias são divididas em regiões de 8 bits, ou byte).

Nosso sistema simplificado conterá três registradores:

PC, contendo o endereço da próxima instrução buscada.
IR, que conterá a instrução buscada a ser executada
AC, um acumulador, que acumulará (somará) os valores ali colocados.

Além disso, nosso sistema terá três INSTRUÇÕES. Cada uma delas estará associada a um código numérico.

0001 - 0x1 - Carregar valor da memória para o acumulador
0010 - 0x2 - Carregar o valor do acumulador de volta na memória
0101 - 0x5 - Somar valor da memória ao acumulador.

Nestas três instruções, verificamos que:

Todas elas referem-se a uma memória. O valor da memória está dentro do valor de 16 bits buscado, conforme a figura abaixo.
Como o "código de operação" tem 4 bits, o endereço de memória só pode ter 12 bits.

Visão do que pode haver numa palavra (word) de 16 bits da nossa plataforma. Uma instrução, com código e endereço (acima), ou um valor inteiro, em sinal/magnitude. Figura de W. Stallings, Computer Organization and Architecture, ed. 6, pag.55, cap3

Vamos agora considerar o programa exemplo propriamente dito. Na figura abaixo, temos a disposição da memória, com algumas instruções guardadas em posições específicas desta, e com dados em outras posições. Além disso, o contador de programa tem guardado dentro dele o endereço da próxima instrução a ser buscada.

Na primeira figura, vemos que o registrador PC contém o endereço da primeira instrução que será buscada, ou seja, 0x300 (hexadecimal). Deve-se notar que este registrador somente alcança endereços de 12 bits, visto que a memória só é endereçavel até 12 bits neste exemplo (lembre-se do código de operação). Logo, no primeiro ciclo de busca, o valor do endereço 0x300 ( 0x1940) é buscado e colocado em IR, o registrador de instrução. Além disso, o contador de instrução é incrementado em 1, indica que no próximo ciclo de busca a instrução será obtida em outro endereço. Ficamos com a figura a seguir:

Agora que o primeiro ciclo de busca foi realizado, devemos realizar o primeiro ciclo de execução: Tomamos a instrução que está em IR, e executamos esta. Os 4 bits iniciais de IR constituem o código de execução, e os 12 bits subsequentes o endereço de memória. Código 1 significa guardar o valor da memória (no caso, 0x940) no acumulador AC. Ora, o valor que está em 0x940 é o número 0x3, que então é colocado em AC, como mostra a figura seguinte.

Terminamos com isto o primeiro ciclo de busca e execução. Vamos ao segundo ciclo. Buscamos no endereço 0x301 a instrução, que é colocada em IR, no lugar da anterior. O PC é incrementado.

O Registrador IR contém o valor 0x5941, que significa que no ciclo de execução deveremos realizar a operação de "somar ao acumulador" (operação 5), o valor que está no endereço 0x941 (que é 2). Então somamos 2 ao acumulador, obtendo 5. Note que, na prática, o acumulador deve "saber" o que fazer com o valor recebido, que neste caso é a soma. A figura a seguir mostra como ficam os registradores.

Agora iniciamos o último ciclo. Buscamos o valor em 0x302, conforme apontado por PC, e guardamos este valor em IR, além de incrementar PC. Veja a figura:

Agora, no ciclo de execução, devemos realizar a operação. No caso, a operação indicada é colocar na memória (endereço 0x941) o valor do acumulador AC, que é 0x5. Fazemos isto, e ficamos com:

Exercício para vocês:

Nossa máquina hipotética contém duas instruções de E/S:

0011 = carregar AC a partir de um dispositivo de E/S
0111 = carregar AC em um dispositivo de E/S

Nestas instruções, o valor de 12 bits designa um dispositivo de E/S particular. Descreva a execução do seguinte programa:

Carregar AC a partir do dispositivo 5.
Somar com o conteúdo da posição de memória 940
Armazenar o conteúdo de AC no dispositivo 6

Suponha que o próximo valor obtido do dispositivo 5 seja 3 e que a posição de memória 940 contenha o valor 2.

Me entreguem até o dia 06/07, as 11:59 da manhã, por email (henriquemarks@gmail.com).

P.S. Podem fazer a mão e me mandar uma foto (ou mais) do trabalho, sem problemas. Mas por favor, reduzam o tamanho do arquivo da foto para algo aceitável, ou seja, algo que eu possa ler e que não seja muito grande. Tenho certeza que, após tirar a foto, pode-se colocar em qualquer programa de imagens (digikam, por exemplo, e salvar a foto em png, com um tamanho MUITO menor).

Trabalho 1 de Sistemas Operacionais Abertos - Cancelado

2010-08-27T12:59:00.000-03:00

Não vou passar trabalho de sistemas operacionais abertos esta semana, acho que não é necessário, ainda. É muito cedo no semestre (apenas duas aulas) e percebi na aula que os alunos entenderam a necessidade de acompanhar as aulas trabalhando nos sistemas que usaremos nos seus computadores (ou seja, precisa ter e usar Linux!).

Vou tentar passar alguns problemas de C e instruções de compilação e execução, para que vocês possam treinar. De qualquer modo, na apostila de C, no capítulo de funções e ponteiros, há exemplos e exercícios.

Aparentemente, o blog tem uma facilidade de seguir posts por email. Ou seja, se você "seguir" o blog, qualquer post nele irá para o seu email, fazendo com que fique mais fácil acompanhar modificações. Alguém fez isto e confirma esta possibilidade, por favor.

Apesar de não ter trabalho, é uma boa idéia aprender a usar estes comandos, ps e top, e alguma interface para eles, como o ksysguard, para entender as informações de processo geradas pelo sistema.

A aula 2 também virá para a internet tão cedo quanto possível.

Sistemas Operacionais Abertos

2010-08-25T16:52:00.000-03:00

Material de C disponível

Material de C para a disciplina. Provavelmente vou pedir para serem feitos os exemplo do livro, e seus exercícios, para entregar. Principalmente o capítulo de Funções, Ponteiros e Estruturas. Na aula combinaremos isto. A linguagem C é condição essencial para esta disciplina, sem ela não podemos trabalhar os conceitos de sistemas operacionais necessários.

Apostila de C

Tomara que este link do DropBox funcione

Java e Swing

2010-08-25T16:44:00.001-03:00

Primeira Aula

Introdução

Ementa da disciplina

Desenvolvimento de aplicações com interface gráfica usando Java e Swing. Implementação de programas utilizando componentes diversos. Integração com bancos de dados. Utilização de Frameworks de Desenvolvimento. Aplicações para sistemas embarcados.

Bibliografia

Livros diversos sobre Java, e sobre Java e Swing, a escolha dos alunos.
Livros específicos sobre Java e Frameworks diversos, dependendo do FrameWork utilizado
Documentação oficial do Java e Swing, em: Documentação oficial do Java

Plano da disciplina

Vamos realizar uma breve introdução ao Java, lembrando conceitos previamente conhecidos. Depois, iremos começar com o Swing, analisando componentes, estrutura de programas, como integrá-los ao IDE utilizado, e fazendo vários programas. A integração aos bancos de dados será trabalhada após termos adquirido um conhecimento sólido em Swing. Após, estudaremos algum FrameWork de Desenvolvimento escolhido no curso e que for considerado adequado, e no final faremos o desenvolvimento de aplicações Java visando os sistemas embarcados, utilizando a plataforma Android.

Tutorial Java, o velho Hello World

Sistemas Operacionais Abertos

2010-08-25T16:24:00.000-03:00

Primeira Aula

O que é um sistema Operacional, informações sobre a disciplina, bibliografia, ementa.
Chamadas de sistema
Linux: Histórico, Distribuições, Licenças. Prática de instalação de uma Distribuição (Ubuntu 10.04) e instalação de programas (usando o instalador de programas Synaptic)

Sistema Computacional: Hardware, Sistema Operacional e Programas de Aplicação

Esquema:

Aplicativos em geral

Compiladores | Shell | Desktop

Sistema Operacional

Linguagem de Máquina

Micro-Arquitetura

Dispositivos Físicos

O que é um Sistema Operacional (SO) ?

O SO é um computador virtual, que esconde das aplicações o hardware, fornecendo aos programas uma interface comum.
O SO gerencia os recursos de hardware, permitindo que estes sejam acessados pelos programas.

Tipos de Sistemas Operacionais

De servidores (UNIX (BSD, OpenSolaris)m Windows Server, Linux
De Multi-Processadores (UNIX, Linux)
Computadores Pessoais (Windows, MAC OS X, Linux)

Nova Geração: Android, Meego, Chrome OS (é tudo Linux)

Tempo Real (VxWorks, IOS, Linux)
Embarcados (Windows CE, JAVA ME, Linux, Symbian, Iphone OS, Android, Meego

Conceitos de Sistemas Operacionais e Nossa Ementa

Processos
Impasses (Deadlocks)
Gerenciamento de Memória
Entrada e Saída
Sistema de Arquivos
Segurança

Introdução: Chamadas de sistemas(syscalls)

O sistema Operacional separa o modo de operação dos programas em modo kernel e modo usuário. O Hardware inclusive faz esta distinção, se o sistema operacional quiser. Todos os SO querem isto. Deste modo os SO atendem requisições dos programas em espaço de usuário, atuando no espaço de kernel, e retornando ao espaço de usuário. A interface que conecta os dois modos são as chamadas de sistema (ou "ao sistema").

Exemplo: Lendo dados de um disco

No espaço de usuário, faremos algumas ações:

Primeiro, o que o programa faz

1 - Armazena nbytes na pilha (que serão escritos)
2 - Armazena &buffer na pilha (endereço de buffer)
3 - Armazena fd na pilha (fd = descritor de arquivo, sua identificação)
4 - Chama read
5 - Incrementa SP (ou limpa a pilha do que não é mais necessário)

Segundo, o que a chamada a read faz

6 - Coloca o código para read no registrador
7 - Trap para o Núcleo
8 - Retorna a quem chamou

No espaço de kernel, outras ações são tomadas:

9 - Despacho
10 - Acesso Físico
11 - Rotinas de Tratamento da syscall

Qual é a ordem das ações ?

Primeiro, temos os passos 1, 2 e 3.
O Passo 4 chama o passo 6.
O Passo 7 faz um trap e manda para o kernel a execução, ou seja, vai para 9.
Os passos 9, 10 e 11, feitos em espaço de kernel, são realizados sequencialmente.
O kernel retorna para 8, que irá retornar ao programa de usuário, desbloqueando este, no passo 5.

Quais chamadas de sistema iremos ver neste curso ?

Muitas. Primeiro as que tratam de processos, porque é o primeiro tópico. Depois as de memória,e assim por diante.

As chamadas de sistema que usaremos, e as rotinas de biblioteca que as usam, estão em C. Logo, trabalharemos em linguagem C.