relatorio/relatorio.tex.backup

   1 \documentclass[a4paper,10pt]{abnt} %
   2 \usepackage[utf8]{inputenc}
   3 \usepackage[T1]{fontenc}
   4 \usepackage[brazil]{babel}
   5 \usepackage{listings}
   6 \usepackage{color}
   7
   8 %opening
   9 %\title{}
  10 %\author{Kauê Silveira \\171671 \and Silveira Kauê \\ 671171}
  11
  12 \autor{Kaue Soares da Silveira \\ 171671} %\and
  13 \instituicao{Universidade Federal do Rio Grande do Sul}
  14 \orientador[Professor:]{Alexandre Carissimi}
  15 \titulo{Trabalho Opcional 1: Estudo da Linguagem Golang}
  16 \comentario{Disciplina INF01151 - Sistemas Operacionais II N}
  17 \data{}
  18
  19 \definecolor{gray}{rgb}{0.5, 0.5, 0.5}
  20 \definecolor{darkBlue}{rgb}{0.15,0.18,0.40}
  21 \definecolor{darkGreen}{rgb}{0.15,0.40,0.18}
  22 \lstset{extendedchars=true,
  23         inputencoding=utf8,
  24         basicstyle=\small\color{blue},
  25         keywordstyle=\color{red}\bfseries,
  26         keywordstyle= [2]\color{magenta}\bfseries,
  27         identifierstyle=\color{blue},
  28         commentstyle=\color{gray}\textit,
  29         stringstyle=\color{magenta},
  30         showstringspaces=false,
  31         tabsize=2
  32 }
  33
  34 \lstset{
  35         numbers=left,         % Números na margem da esquerda
  36         numberstyle=\tiny\color{darkGreen},    % Números pequenos
  37         stepnumber=1,         % De 1 em 1
  38         numbersep=5pt         % Separados por 5pt
  39 }
  40 \lstdefinelanguage{Go}{%
  41       morekeywords=[1]{func, int, chan, \(, \), \{, \}, "(", "\{"},% blocks
  42       morekeywords=[2]{make, go, select},%
  43       morekeywords=[2]{variable,ns-default,ns-prefix,not,if,then,else,case,without,desc,descendant,in,identity},%
  44       morekeywords=[3]{idvar,var,->,as},% variables
  45       morekeywords=[4]{lexical,sum,count,join},% aggregation/sorting
  46       morekeywords=[5]{},% regexps (s.moredelim below)
  47       morestring=[b]",%
  48       morecomment=[l]{\#},%
  49       morecomment=[l]{//},%
  50       morecomment=[s]{\\\#}{\#\\\\)},%
  51       alsodigit={-},%
  52       literate= {->}{$\rightarrow$}{2},%
  53       sensitive%
  54     }[keywords,strings]
  55
  56 \lstdefinelanguage{Shell}{%
  57       morekeywords=[1]{sudo, apt-get, install, cd, export, hg, mkdir, mv, gedit, easy_install, clone, release, g, l},% blocks
  58       morekeywords=[2]{declare,some,position,pos,optional,opt,where,order-by,group-by,and,or,not},%
  59       morekeywords=[2]{variable,ns-default,ns-prefix,not,if,then,else,case,without,desc,descendant,in,identity},%
  60       morekeywords=[3]{idvar,var,->,as},% variables
  61       morekeywords=[4]{lexical,sum,count,join},% aggregation/sorting
  62       morekeywords=[5]{},% regexps (s.moredelim below)
  63       morestring=[b]",%
  64       morecomment=[l]{\#},%
  65       morecomment=[s]{\\\#}{\#\\\\)},%
  66       alsodigit={-},%
  67       literate= {->}{$\rightarrow$}{2},%
  68       sensitive%
  69     }[keywords,strings]
  70
  71 \begin{document}
  72
  73 %\maketitle
  74 \folhaderosto
  75 \sumario
  76
  77 %\begin{abstract}
  78 %\begin{resumo}
  79 %\end{abstract}
  80 %\end{resumo}
  81
  82 \chapter{Introducao}
  83
  84 \chapter{Instalação}
  85         Passos que eu segui no Ubuntu 9.10:
  86
  87 \begin{lstlisting}[language=Shell, texcl=true, escapechar={\%}]
  88 cd ~
  89 gedit .bashrc &
  90         # colar no final:
  91         export GOROOT=$HOME/go
  92         export GOARCH=386
  93         export GOOS=linux
  94 # reiniciar o shell para que as alterações tenham efeito
  95 sudo apt-get install bison gcc libc6-dev ed gawk make
  96 sudo apt-get install python-setuptools python-dev build-essential gcc
  97 sudo easy_install mercurial
  98 hg clone -r release https://go.googlecode.com/%hg%/ $GOROOT
  99 cd $GOROOT/src
 100 mkdir $HOME/bin
 101 ./all.bash
 102 cd $HOME/bin
 103 sudo mv * /bin
 104 \end{lstlisting}
 105
 106 \section{Utilização}
 107 \begin{lstlisting}[language=Shell, texcl=true, escapechar={\%}]
 108 # criar o arquivo fonte num editor de sua preferência
 109 gedit prog.go & # -> prog.go
 110 # compilar
 111 %\color{red}{8}%g prog.go # -> prog.8
 112 # ligar
 113 %\color{red}{8}%l -o prog prog.8 # -> prog
 114 # executar
 115 ./prog
 116 \end{lstlisting}
 117
 118 \chapter{Mecanismos de Programação Concorrente}
 119         \section{Channel}
 120                 Representa um cana de comunicação / sincronização que pode conectar duas
 121 computações concorrentes. Na realidade são referências para um objeto que
 122 coordena a comunicação.
 123
 124                 <- é o operador binário de comunicação (envio) <- também é o operador, desta vez unário, de recebimento. Ambos são atômicos.
 125
 126                 Operações de leitura (respesctivamente, escrita) em canais que não têm buffer ou que estão com o buffer vazio (respectivamente, cheio) bloqueiam, e o bloqueio se mantém até que haja aconteça uma operação de escrita (respectivamente, leitura). A linguagem também permite leitura (respectivamente, escrita) não bloqueante, a qual retorna imediatamente uma flag dizendo se a operação foi realizada com sucesso ou não.
 127
 128                 Na criação são sempre bidirecionais, mas quando são recebidos como parâmetro por uma função, além da declaração normal (chan T) podem ser declarados para apenas receber (<-chan T) e apenas enviar (chan<- T), com o objetivo garantir que serão utilizados corretamente no corpo da função.
 129
 130                 Exemplos:
 131 \begin{lstlisting}[language=Go, texcl=true, escapechar={\%}]
 132 // criação de um canal sincrono para transmissão de inteiros
 133 canal_sincrono %\color{red}:=% make (chan int)
 134 // criação de um canal assincrono (enquanto houver espaço no buffer)
 135 // com buffer de tamanho 10 (inteiros)
 136 canal_assincrono %\color{red}:=% make (chan int, 10)
 137 // função que utiliza um canal apenas para leitura
 138 func so_leio (canal_leitura %\color{red}<-%chan int) { ... }
 139 // função que utiliza um canal apenas para escrita
 140 func so_escrevo (canal_escrita chan%\color{red}<-% int) { ... }
 141 // função que utiliza um canal bidirecional
 142 func leio_e_escrevo (canal chan int) { ... }
 143 // tipos de leitura:
 144 v %\color{red}:=% %\color{red}<-%canal_sincrono // sempre leitura sincrona
 145 v %\color{red}:=% %\color{red}<-%canal_assincrono // leitura assincrona quando houver espaço no buffer, síncrona caso contrário
 146 v, ok %\color{red}:=% %\color{red}<-%canal // sempre leitura assíncrona, ok é setado para true ou false de acordo com o sucesso
 147 // tipos de escrita:
 148 canal_sincrono %\color{red}<-% v // sempre escrita síncrona
 149 canal_assincrono %\color{red}<-% v // escrita assíncrona quando houver espaço no buffer, síncrona caso contrário
 150 ok %\color{red}:=% canal %\color{red}<-% v // sempre escrita assíncrona, ok é setado para true ou false de acordo com o sucesso
 151
 152 \end{lstlisting}
 153
 154         \section{Gorotinas}
 155                 Go tem seu próprio modelo de processo / thread / corotina,
 156 chamado gorotina (\emph{goroutines}). Gorotinas são divididas de acordo com o necessário em threads (de usuário) e processos do sistema. Quando uma goroutine executa uma chamada de sistema bloqueane, nenhuma outra gorotina é bloqueada. Para configurar o número máximo de processos criados podemos modificar a variável de ambiente \$GOMAXPROCS ou utilizar a função runtime.GOMAXPROCS (n int) durante a execução. Seu valor default é 1, ou seja, todas as gorotinas são threads de usuário pertencentes ao mesmo processo.
 157
 158                 \subsection{go}
 159                         É o operador que inicia a execução concorrente de uma gorotina, sempre no mesmo espaço de endereçamento. Prefixe uma chamada de função ou de método com a palavra-chave go para executar a chamada numa nova gorotina. Quando a chamada termina, a gorotina também termina (silenciosamente). O efeito é similar a notação \& do shell Unix para rodar um comando em background.
 160
 161                         Exemplo:
 162
 163 \begin{lstlisting}[language=Go, texcl=true, escapechar={\%}]
 164 ...
 165 func faz_algo () { ... }
 166 ...
 167 func main () {
 168         ...
 169         // inicia a execução concorrente da função \emph{faz\_algo} ...
 170         go faz_algo ()
 171         // ... e continua executando ...
 172         ...
 173 }
 174 \end{lstlisting}
 175
 176
 177                 \subsection{select}
 178                         É um estrutura de controle análoga a um switch de comunicações. Cada caso
 179 deve ser um send ou receive. escolhe qual das comunicações listadas em seus
 180 casos pode prosseguir. Se todas estão bloqueadas, ele espera até que alguma
 181 desbloqueie. Se várias podem prosseguir, ele escolhe uma aleatoriamente.
 182                 sumário:
 183                         todos os casos devem ser uma comunicação
 184                         todas as expressões com canal são avaliadas
 185                         todas as expressões a serem enviadas são avaliadas
 186                         se qualquer comunicação pode prosseguir, ela o faz, e as outras são
 187 ignoradas
 188                         caso contrário:
 189                                 se há uma cláusula default, ela executa
 190                                 se não há default, o select bloqueia até que alguma comunicação possa
 191 prosseguir. não há re-avaliação de canais ou valores
 192                         se várias cláusulas estão prontas, uma é escolhida aleatoriamente, de
 193 maneira justa, e as outras não executam.
 194                         random bit generator
 195                                 for {
 196                                         select {
 197                                         case c <- 0:
 198                                         case c <- 1:
 199                                         }
 200                                 }
 201
 202
 203         defer executa uma função apenas quando a função que o chama retorna. Útil para
 204 destrancar mutexes.
 205
 206         Filosofia: "não comunique compartilhando memória. Em vez disso, compartilhe
 207 memória comunicando-se." O simples ato de comunicação garante a sincronização.
 208
 209         Concorrência em muitos ambientes se torna difícil pelas sutilezas envolvidas
 210 no acesso correto a variáveis compartilhadas. Go encoraja uma abordagem
 211 diferente, na qual variáveis compartilhadas são passadas através de canais e
 212 nunca são de fato ativamente compartilhadas por threads de execução separadas.
 213 Apenas uma gorotina tem acesso à variável num dado momento de tempo. Condições
 214 de corrida relativas aos dados não podem ocorrer, por construção.
 215
 216         concorrência inspirada no CSP.
 217
 218         Exclusão Mútua:
 219                 Criação:
 220                 Uso:
 221                 Destruição:
 222                 Implementação:
 223                         Problema produtor-consumidor com buffer limitado e taxa de
 224         produção e consumo aleatórias.
 225         Semáforos:
 226                 Criação:
 227                 Uso:
 228                 Destruição:
 229                 Implementação:
 230                         Problema produtor-consumidor com buffer limitado e taxa de
 231         produção e consumo aleatórias.
 232         Monitores:
 233                 Criação:
 234                 Uso:
 235                 Destruição:
 236                 Implementação:
 237                         Problema produtor-consumidor com buffer limitado e taxa de
 238         produção e consumo aleatórias.
 239         Variáveis de Condição:
 240                 Criação:
 241                 Uso:
 242                 Destruição:
 243                 Implementação:
 244                         Problema produtor-consumidor com buffer limitado e taxa de
 245         produção e consumo aleatórias.
 246
 247 Processos, Threads ou Ambos?
 248
 249 Funções Úteis:
 250         time.Sleep(int)
 251         func init()
 252         http://golang.org/pkg/sync/
 253         http://golang.org/doc/go\_mem.html
 254
 255 \end{document}