Sistema Operacional IOS

iOS

1 - Chamada de sistema/API

Conceitualmente sabemos que as chamadas de sistema

fornecem uma interface com os

serviços disponibilizados por um sistema operacional. Vamos

nos limitar aqui a

descrever apenas uma das várias chamadas de sistema do iOS,

que é para criação de

processos. [1]

É relevante citar que a API especifica um conjunto de funções

que estão disponíveis

para o programador de aplicações, inclusive os parâmetros que

são passados para cada

função e os valores de retorno que o programador pode

esperar. Uma das APIs mais

comuns para programadores de aplicações é a API POSIX, na

qual o iOS tem em suas

versões [1].

Bom, vamos começar com a chamada fork(2).

Nome.

fork – cria um novo processo.

Sinopse.

#include <unistd.h>

pid_t

fork(void);

Descrição da chamada.

fork( ) provoca a criação de um novo processo. O novo

processo (processo filho) é uma

cópia exata do processo de chamada (processo pai), exceto

para o seguinte:

• O processo filho tem um ID único.

• O processo filho tem um ID diferente do processo pai

(isto é, o processo de identificação do processo pai).

• O processo filho tem sua cópia de descritores do pai.

Estes descritores referenciam os mesmos objetos subjacentes,

de modo que, por exemplo, ponteiros de arquivos em objetos

de arquivo são compartilhados entre o processo filho e o

processo pai, para que outra chamada de sistema que tem o

nome de lseek(2) em um descritor do processo filho pode afetar

uma leitura posterior do pai.

Valores de retorno.

Após a conclusão, o fork( ) retorna um valor de 0 para o filho

processar e retorna o ID

do processo filho para o processo pai. Caso contrário, um valor

de -1 é retornado para o

processo pai.

Erros.

Fork( ) irá falhar e nenhum processo filho será criado se:

1 - O limite do sistema impõe sobre o número total de processos

em execução, se o

mesmo for excedido. Esse limita é a configuração-dependente.

2 - O limite do sistema-imposto MAXUPRC (<sys/param.h>)

sobre o número total de

processos em execução por um único usuário, estaria

ultrapassado.

3 - Existe espaço de troca insuficiente para o novo processo.

Ressalvas.

Há limites para que o usuário possa fazer no processo filho.

Para ser totalmente seguro,

o usuário deve restringir-se apenas à execução assíncrona de

sinal a segurança das

operações até que uma das funções exec é chamado. Todas as

APIs, incluindo símbolos

de dados globais, em qualquer quadro ou biblioteca deve ser

considerada insegura

depois de um fork( ) a menos que explicitamente documentado

para ser seguro ou sinalasync

segura. Se o usuário precisar usar essas estruturas no processo

filho, o mesmo

deve fazer o uso das funções exec.

2 - Estrutura do sistema.

O kernel no iOS é baseado em uma variante do kernel Mach

mesma base que é encontrada em Mac OS X. No topo deste

kernel estão as camadas de serviços que são utilizados para

implementar os aplicativos.

O nível do sistema engloba o kernel, drives, e interfaces UNIX

de baixo nível do sistema operacional. O kernel em si é baseado

em Mach e é responsável por todos os aspectos do sistema

operacional. Ele gerencia o sistema de memória virtual, threads,

sistema de arquivos, rede e comunicação entre processos.

Os drives nesta camadatambém fornecem a interface entre

o hardware disponível e frameworks do sistema. Para fins de

segurança, o acesso ao kernel e drives é restrito a um conjunto

limitadode frameworks do sistema e aplicativos.

• Cocoa Touch; - Alto nível

Esta cama é composta por frameworks chave que fornecem

uma infra estrutura necessária para realizar aplicações no

sistema operacional.

• Media;

Encontra-se o que diz respeito as tecnologias gráficas, de

áudio e de vídeo voltadas para criação da melhor experiência

multimídea disponíveis.

• Core Services;

Fornece os serviços fundamentais do sistema que todas as

aplicações usam como o core-foudation que oferece interfaces

de gestão de dados básicas para aplicações, ou como o

core location que permite determinar a localização de um

dispositivo.

• Core OS; - Baixo Nível

Camada que permite o telefone fazer aquilo para o qual foi

desenhado, sendo a ponte entre todas as outras camadas e o

hardware. Implementa ainda toda a segurança do sistema bem

como as interfaces para abstração na forma como trabalhar

com as camadas de rede e transporte.

3 - Histórico - quando, por que, evolução

O sistema operacional foi apresentado com o iPhone

na "Macworld Conference & Expo" em 9 de janeiro de 2007, e

lançado no mês de junho.

Em 17 de outubro de 2007, a Apple anunciou que a SDK nativa

estava em desenvolvimento e que eles esperassem para colocá-

la nas "mãos dos desenvolvedores". Em 6 de março de 2008,

a Apple lançou o primeiro beta, juntamente com um novo nome

para o sistema operacional: o "iPhone OS". A rápida venda de

dispositivos móveis da Apple acendeu interesse no SDK. A Apple

também vendeu mais de um milhão deiPhones durante uma

temporada de feriados de 2007. Em 27 de janeiro de 2010, a

Apple anunciou o iPad, com uma tela bem maior do que o iPhone

e iPod touch, e projetado para navegar na web, o consumo de

mídia, e da leitura de iBooks.

4- Criação de processos

Fork() -> exec()

spawn()

5- Comunicação interprocessos

Sinais - Semáforos permitem aos processos consultar ou alterar

as informações de status. Eles são freqüentemente usados ​​para

monitorar e controlar a disponibilidade de recursos do sistema,

tais como segmentos de memória compartilhada.

Memória Compartilhada - É um modo usado para passar dados

entre processos. Um dos processos aloca um segmento de

memória, e indica quais outros processos podem acessá-lo.

Fila de Mensagens - Dois ou mais processos compartilham

dados através do acesso à uma fila comum de mensagens

do sistema. Cada mensagem recebe uma identificação, para

que outros processos consigam identificar o conteúdo a ser

acessado.

6- Threads

O iOS é construído sobre o kernel do Linux versão 2.6, o qual

fornece serviço de segurança, gerenciamento de memória e

processos (threads), além de disponibilizar uma pilha

de protocolos de rede. O kernel é a primeira camada de

abstração entre o hardware do

dispositivo e o restante da pilha de softwares que compõem iOS.

7- Escalonamento

Normal: Prioridade das Aplicações Normais do Usuário.

Sistema: Prioridade das Aplicações do Sistema.

Kernel: Reservada para Threads em Espaço de Kernel.

Tempo Real: Threads nas quais a Prioridade Está Baseada na

Necessidade de Reservar

uma Fração Pré-Definidas de Ciclos de Clock.

Sincronização

No posix, a sincronização é feita através de sinais.

Um sinal é uma mensagem enviada para um ou mais processos,

a qual carrega como informação um identificador. No sistema

operacional, alguns eventos irão gerar diferentes tipos de sinais

que os identificarão, como por exemplo:

- um acesso inválido à uma região de memória

- operação matemática inválida

- operações de i/o mal sucedidas

- requisição do usuário para interromper um programa (^c ou ^z)

Gerenciamento de Memória

O gerenciamento de memória de um determinado aplicativo no iOS, é o processo de

alocação de memória durante a execução do seu programa, utilizando-o e em seguida

liberando quando terminado. Um código bem escrito/compilado usa o mínimo de

memória possível. Na linguagem Objective C, o programa pode também ser visto como

uma forma de distribuir a propriedade de recursos de memória limitados entre pedaços

de dados e de códigos.

Embora o gerenciamento de memória é normalmente considerado ao nível de um objeto

individual, seu objetivo é realmente para gerenciar gráficos de determinados objetos.

Todavia, o usuário tem que ter certeza de que o mesmo não tem mais objetos na

memória do que realmente precisa (necessita).

Figura 2: Gerenciamento de Memória. Fonte: developer.apple.com/library/ios/

Continuando o assunto, é relevante citar que o Objective-C fornece três métodos de

gerenciamento de memória de aplicativo.

1 - Ao decorrer do texto, iremos descrever o método conhecido como “Manual Reter-

Release” ou MRR, onde o usuário pode explicitamente gerenciar a memória, mantendo

o controle de objetos que o mesmo possui. Isto é implementado utilizando um modelo,

conhecido como a contagem de referência, que a base de classe NSObject fornece em

conjunto com o ambiente de execução.

2 - Em um contador automático de referência (Automatic Reference Countign, ou

ARC), o sistema usa o mesmo sistema de contador de referência que o MRR, mas insere

as chamadas de métodos gerenciamento de memórias apropriadas para o usuário em

tempo de compilação.

3 – No coletor de lixos, o sistema automaticamente acompanha que objetos pertencem

as quais outros objetos. Isso, então, automaticamente livra (ou coleta o lixo) os objetos

que não estão referenciados. Ele usa um mecanismo diferente daquele empregado no

MRR ou ARC e é apenas suportado no ambiente de execução do Mac OS X, não no Ios.

Se um usuário pensa em escrever um código para o Ios, o mesmo deve usar o

gerenciamento de memória explícita, além disso, estas técnicas de gerenciamento

de memória devem ser consideradas ao se escrever bibliotecas de rotinas, plug-ins,

ou código compartilhado tanto em processos coletores de lixo como processos não

coletores de lixo.

• Boas práticas para prevenção de problemas de memórias relacionadas.

Existem dois tipos principais de problemas ou que resultam num gerenciamento

incorreto de memória, são esses:

1 – Liberação ou substituição de dados que ainda estão em uso.

Isso faz com que a decomposição de memória, normalmente, resulte em falha do

aplicativo, ou ainda pior, que os dados do usuário sejam corrompidos.

2 – A não liberação dos dados que estão em desuso faz com que ocorram vazamentos de

memória.

Um vazamento é onde a memória alocada não é liberada, mesmo que ela não torne a

ser utilizada novamente. Vazamentos que fazem com que o aplicativo use quantidades

cada vez maiores de memória, que pode resultar num péssimo desempenho do sistema

operacional.

Pensando em gerenciamento de memória a partir da perspectiva de contagem de

referência, que, no entanto, é frequentemente contraditório, porque o usuário tende

a considerar o gerenciamento de memória em termos de detalhes de implementação,

em vez de em termos de seus objetivos reais. Logo, o usuário deve pensar em

gerenciamento de memória a partir da perspectiva da propriedade de objeto e gráficos

de objetos.

O Cocoa utiliza uma convenção de nomeação direta para indicar quando o usuário

possui um objeto retornado por um método.

Embora a política de base seja simples, existem algumas medidas práticas que o

usuário pode tomar para tornar mais fácil a gestão/controle da memória, para ajudar a

garantir que o programa permaneça confiável e robusto ao mesmo tempo em que são

minimizados os requisitos de seus recursos.

• Uso de ferramentas de análise para depurar problemas de memória.

Para identificar problemas com o seu código em tempo de compilação, o usuário pode

usar o “Clang Static Analyzer” que está embutido no Xcode.

Se os problemas de gerenciamento de memória que no entanto, surgem, existem

outras ferramentas e técnicas que o usuário pode usar para identificar e diagnosticar os

problemas.

1. Muitas das ferramentas e técnicas são descritas em Nota Técnica TN2239, iOS

Debugging Magic e em particular, o uso de NSZombie para ajudar a encontrar o objeto.

2. O usuário pode usar instrumentos para acompanhar os eventos de contagem de

referência e procurar vazamentos de memória.

Referências

http://faculty.cs.tamu.edu/bettati/Courses/313/2013B/Slides/

POSIXIPC.pdf

http://www.lsd.ic.unicamp.br/mo806/index.php/IOS

https://developer.apple.com/library

http://developer.apple.com/library/ios/#documentation/System/

Conceptual/ManPages_iPhoneOS/index.html#//apple_ref/doc/

uid/TP40007259

http://www.cs.cf.ac.uk/Dave/C/node25.html

http://www.cs.cf.ac.uk/Dave/C/node27.html

http://www.cs.cf.ac.uk/Dave/C/node26.html

http://saloon.inf.ufrgs.br/twiki-data/Disciplinas/INF01008/

TF10DiogoSilvaLucianoSiqueira/TFinal.pdf

Gerenciamento de memória :

https://developer.apple.com/library/mac/#documentation/General/

Conceptual/Dev

Pedia-CocoaCore/MemoryManagement.html