Ficha OCaml 0: Os primeiros passos com OCaml

Esta ficha tem por objetivo a vossa familiarização com as ferramentas básicas de compilação e execução de programas OCaml. Não importa assim tanto aqui perceber em detalhe os programas OCaml que vamos utilizar. Estes vos parecerão familiar mais adiante nesta Unidade Curricular. Não nos debruçaremos sobre o uso dos compiladores que produzem javascript.

Ex. Como compilar?

Considere a seguinte implementação do algoritmo designado de Trabb-Pardo-Knuth. Este algoritmo não tem nenhuma outra utilidade fora o de ser um algoritmo da classe "hello world!" que exemplifica muito comodamente e simplesmente algumas características da linguagem de programação usada.

1
ler 11 números para uma sequência A
2
para cada item na sequência A, do último ao primeiro
3
   calular uma função sobre este item
4
   se o resultado ultrapassar um limite predefinido
5
      alertar o utilizador
6
   senão
7
      imprimir o resultado a função

Uma tradução literal deste algoritmo em Ocaml é:

​x
1
open Float
2
open Array
3

4
let f t =  sqrt (abs t) +. 5. *. (t ** 3.)
5

6
let a = init 11 (fun _ -> read_float ())
7

8
let () =
9
  for i=10 downto 0 do
10
    let msg =
11
      let y = f a.(i) in
12
      if y <= 400. then (string_of_float y) else  "TOO LARGE" in
13
    print_endline msg
14
  done
15
  

Neste exemplo definimos a função por usar como sendo $f=x\mapsto \sqrt{|x|}+5\times x^3$$f = x \mapsto \sqrt{|x|} + 5\times x^3$, e o limite como sendo 400.

1. Passe este programa para um ficheiro de nome tpk0.ml.

2. Compile este ficheiro com o compilador ocamlopt da seguinte forma: ocamlopt tpk0.ml -o tpk0n.

3. Compile este ficheiro com o compilador ocamlc da seguinte forma: ocamlc tpk0.ml -o tpk0b.

4. Execute os dois programas (tpk0n e tpk0b) na linha de comando com base em 11 valores introduzidos no teclado. Por exemplo

   xxxxxxxxxx
   24
   1
   $ ./tpk0n
   2
   -1
   3
   54
   4
   2
   5
   73
   6
   4
   7
   100
   8
   466
   9
   400
   10
   10000
   11
   -76
   12
   39
   13
   TOO LARGE
   14
   -2194871.2822
   15
   TOO LARGE
   16
   TOO LARGE
   17
   TOO LARGE
   18
   TOO LARGE
   19
   322.
   20
   TOO LARGE
   21
   41.4142135624
   22
   TOO LARGE
   23
   -4.
   24
   
   

   ou, se colocamos as entradas num ficheiro input.txt (desejável) :

   xxxxxxxxxx
   13
   1
   $ ./tpk0n < input.txt
   2
   TOO LARGE
   3
   -2194871.2822
   4
   TOO LARGE
   5
   TOO LARGE
   6
   TOO LARGE
   7
   TOO LARGE
   8
   322.
   9
   TOO LARGE
   10
   41.4142135624
   11
   TOO LARGE
   12
   -4.
   13
   
   

    

5. Experimente o programa dentro de um toplevel. Aconselhamos o uso de utop. Nota: depois do copy-paste do código, não se esqueça de juntar dois pontos-e-vírgulas ;; e carregar no enter.

6. Uma versão mais no espírito da programação funcional é :

   xxxxxxxxxx
   7
   1
   open List
   2
   let v = (fun _ -> read_float ())  |> (init 11)   |> rev
   3
   let f x =
   4
     let t = (Float.sqrt (Float.abs x) +. 5. *. (x ** 3.)) in
   5
     t |> (fun u -> if u > 400. then  "TOO LARGE" else string_of_float u)
   6
       |> print_endline        
   7
   let ()  = iter f v
   

   Compile com os dois compiladores e execute as duas versões.

Ex. A diferença entre ocamlopt e ocamlc.

Considere o seguinte código OCaml:

xxxxxxxxxx
11
1
let () =
2
  for i=1 to int_of_string Sys.argv.(1) do
3
    print_float (Random.float (float_of_string Sys.argv.(2))); print_newline ()
4
  done
5
(* (* uma forma alternativa *)
6
let () =
7
  for i=1 to int_of_string Sys.argv.(1) do
8
    Sys.argv.(2) |> float_of_string |> Random.float |> print_float ;  
9
    print_newline ()
10
  done
11
*)  

1. Copie este programa no ficheiro gen_floats.ml e compile com ocamlopt gen_floats.ml -o gen_floats.
2. Este programa, quando invocado por ./gen_floats X Y gere X números flutuantes entre 0 e Y (excluído), na saída standard. Experimente a sua execução, por exemplo com os valores 11 e 800 : ./gen_floats 11 800.
3. Considere o seguinte programa OCaml que junta o código acima descrito com o do exercício anterior.

xxxxxxxxxx
31
1
(* os parâmetros fornecidos na linha de comando *)
2
let amostras = int_of_string Sys.argv.(1)
3
let quantos  = int_of_string Sys.argv.(2)
4
let limite   = float_of_string Sys.argv.(3)
5

6
(* a função por avaliar*)
7
let f t =  Float.sqrt (Float.abs t) +. 5. *. (t ** 3.)
8

9
(* o algoritmo tpk *)
10
let tpk () =
11
  let  a = Array.init quantos (fun _ ->  Random.float limite) in
12
  for i= quantos - 1 downto 0 do
13
    let msg =
14
      let y = f a.(i) in
15
      if y <= 400. then (string_of_float y) else  "TOO LARGE" in
16
    print_endline msg
17
  done
18

19
(* para medir o tempo entre o início e o fim de uma execução de f com o argumento x*)
20
let time f x =
21
    let t = Sys.time() in
22
    let fx = f x in
23
    let () = Printf.eprintf "Execution time: %fs\n" (Sys.time() -. t) in
24
    fx
25

26
(* avaliar "amostras" vezes a função f sobre x *)
27
let eval f x = for i=1 to amostras do f x done
28

29
(* execução principal *)
30
let () = time (eval tpk) ()
31
    

Vamos executar o código do exercício anterior muitas vezes sobre dados gerados aleatoriamente e medir o tempo. Iremos assim mostrar na prática uma diferença de desempenho entre a versão compilada por ocamlc e ocamlopt.

• compile este programa com os dois compiladores, para tpkbenchb na versão bytecode e tpkbenchbn na versão nativa.

• Execute cada um dos executáveis por forma a que a saída standard seja ignorada, que haja um milhão de execução do algoritmo de trabb-pardo-knuth .

  Deverá obter algo semelhante aos tempos seguintes :

xxxxxxxxxx
4
1
$ ./tpkbenchb 1000000 11 800 > /dev/null
2
Execution time: 9.682373s
3
$ ./tpkbenchn 1000000 11 800 > /dev/null
4
Execution time: 6.205420s

4. Como explica a diferença?

Ex. Bestiário de Erros de Compilação.

Voltemos ao exemplo original. Explique para cada uma das alíneas seguintes o(s) erro(s) que encontra.

Alguns deles são detetados na compilação outros na execução. Proponha uma correção.

1.  

   xxxxxxxxxx
   14
   1
   open Float
   2
   open Array
   3
   
   4
   let f t =  sqrt (abs t) + 5. *. (t ** 3.)
   5
   
   6
   let a = init 11 (fun _ -> read_float ())
   7
   
   8
   let () =
   9
     for i=10 downto 0 do
   10
       let msg =
   11
         let y = f a.(i) in
   12
         if y <= 400 then (string_of_float y) else  "TOO LARGE" in
   13
       print_endline msg
   14
     done
   

2.  

   xxxxxxxxxx
   12
   1
   let f t = sqrt (abs t) +. 5. *. (t ** 3.)
   2
   
   3
   let a = init 11 (fun _ -> read_float ())
   4
   
   5
   let () =
   6
     for i=10 downto 0 do
   7
       let msg =
   8
         let y = f a.(i) in
   9
         if y <= 400. then (string_of_float y) else  "TOO LARGE" in
   10
       print_endline msg
   11
     done
   12
     
   

3.  

   xxxxxxxxxx
   15
   1
   open Float
   2
   open List
   3
   
   4
   let f t =  sqrt (abs t) +. 5. *. (t ** 3.)
   5
   
   6
   let a = init 11 (fun _ -> read_float ())
   7
   
   8
   let () =
   9
     for i=10 downto 0 do
   10
       let msg =
   11
         let y = f a.(i) in
   12
         if y <= 400. then y else  "TOO LARGE" in
   13
       print_endline msg
   14
     done  
   15
     
   

4.  

   xxxxxxxxxx
   12
   1
   open Float
   2
   
   3
   let f t =  sqrt (abs t) +. 5. *. (t ** 3.)
   4
   
   5
   let a = Array.init 11 (fun _ -> read_line ())
   6
   
   7
   let () =
   8
     for i=10 downto 0 do
   9
       let msg =
   10
         let y = f a.(i) in
   11
         if y <= 400. then (string_of_float y) else  "TOO LARGE" in
   12
       print_endline 
   

5.  

   xxxxxxxxxx
   13
   1
   open Float 
   2
   
   3
   let f t =  sqrt (abs t) +. 5. /. (10. -. t)
   4
   
   5
   let a = Array.init 11 (fun _ -> read_float ())
   6
   
   7
   let () =
   8
     for i=11 downto 0 do
   9
       let msg =
   10
         let y = f a.(i) in
   11
         if y <= 400. then (string_of_float y) else  "TOO LARGE" in
   12
       print_endline msg
   13
     done
   

6. xxxxxxxxxx
   13
   1
   open Float 
   2
      
   3
      let f t =  sqrt (abs t) +. 5. *. (t ** 3.)
   4
      
   5
      let b = Array.init 11 (fun _ -> read_float ())
   6
      
   7
      let () =
   8
        for i=10 downto 0 do
   9
          let msg =
   10
            let y = f 0.5 a.(i) in
   11
            if y <= 400. then (string_of_float y) else  "TOO LARGE" in
   12
         print_endline msg
   13
        done
   

7.  

   xxxxxxxxxx
   13
   1
   open Float 
   2
   
   3
   let f t = sqrt (abs t) +. 5. *. (t ** 3.)
   4
   
   5
   let a = Array.init (fun _ -> read_float ())
   6
   
   7
   let () =
   8
     for i=10 downto 0 do
   9
       let msg =
   10
         let y = f a.(i) in
   11
         if y <= 400. then "TOO LARGE" in
   12
        print_endline msg
   13
     done
   

    

Quer saber mais ? Veja Common Error Messages.

Ex. Compilação de programas que usam bibliotecas externas

O objetivo deste exercício é perceber como compilar programas que fazem uso de bibliotecas externas, isto é, de funcionalidades que não pertençam a biblioteca padrão. A página Compiling OCaml projects lista as diferentes formas de compilar um programa conforme as bibliotecas que pode vir a usar. Vamos aqui ilustrar este processo com um programa que usa a biblioteca gráfica Graphics.

Esta instala-se de forma habitual:

xxxxxxxxxx
1
1
opam install graphics

Recupere o ficheiro graph_example.ml no seguinte site (link).

1. Compile este programa com a ajuda da ferramenta ocamlfind conforme a documentação indicada no início do exercício.
2. Execute o programa e interaja com ele. Para sair da animação gráfica, basta pressionar uma tecla qualquer.

Ex. Perfilar um programa.

O objetivo deste exercício é conhecer como se obtém um perfil de um determinado programa. Vamos fazê-lo para o programa executado em modo bytecode, mas de forma muito semelhante se faz o perfil de um programa em modo nativo. Para mais opções sobre como perfilar um programa, ver a documentação do ocamlprof.

Consideremos novamente o programa de teste temporal do algoritmo TPK.

xxxxxxxxxx
31
1
(** os parâmetros fornecidos na linha de comando *)
2
let amostras = int_of_string Sys.argv.(1)
3
let quantos  = int_of_string Sys.argv.(2)
4
let limite   = float_of_string Sys.argv.(3)
5

6
(** a função por avaliar*)
7
let f t =  Float.sqrt (Float.abs t) +. 5. *. (t ** 3.)
8

9
(** o algoritmo tpk *)
10
let tpk () =
11
  let  a = Array.init quantos (fun _ ->  Random.float limite) in
12
  for i= quantos - 1 downto 0 do
13
    let msg =
14
      let y = f a.(i) in
15
      if y <= 400. then (string_of_float y) else  "TOO LARGE" in
16
    print_endline msg
17
  done
18

19
(** para medir o tempo entre o início e o fim de uma execução de f com o argumento x*)
20
let time f x =
21
    let t = Sys.time() in
22
    let fx = f x in
23
    let () = Printf.eprintf "Execution time: %fs\n" (Sys.time() -. t) in
24
    fx
25

26
(** avaliar "amostras" vezes a função f sobre x *)
27
let eval f x = for i=1 to amostras do f x done
28

29
(** execução principal *)
30
let () = time (eval tpk) ()
31
    

1. Gravar este programa no ficheiro tpkp.ml. Compilar este programa com o compilador ocamlcp (p de "profile"), usando o comando ocamlcp -P a tpkp.ml -o tpkp.

2. Executar o programa perfilado tpkp da forma usual. Por exemplo :

   xxxxxxxxxx
   1
   1
   $ ./tpkp 1000000 11 800
   

   Esta execução criou um ficheiro binário ocamlprof.dump com todas as informações de execução que precisamos agora de recuperar e processar. É o objeto da alínea seguinte.

3. Usar o utilitário ocamlprof que analisa um ficheiro ml e junta a informação de perfil a partir do ficheiro ocamlprof.dump.

   xxxxxxxxxx
   1
   1
   $ ocamlprof tpkp.ml > tpkp_perfilado.ml
   

    

4. Analise o ficheiro tpkp_perfilado.ml. Que parte do programa é o mais requisitado?

Ex. Geração de Documentação.

Execute o utilitário de geração de documentação disponível por omissão na distribuição OCaml, ocamldoc (documentação). Usos mais avançados poderão passar, com muito proveito, por ferramentas como odoc.

xxxxxxxxxx
1
1
$ ocamldoc -html -keep-code tpkp.ml

Explore os ficheiros gerados com recurso ao seu browser (tpkp.html, index.html, etc.).

Ex. Uma ferramenta para o advogado do diabo.

Vamos usar um dos muitos programas de testes existentes para programas OCaml : o utilitário de fuzz-testing afl para OCaml (documentação).

1. Instale o afl para OCaml:

   xxxxxxxxxx
   1
   1
   $ opam install afl
   

2. Considere o seguinte programa :

   xxxxxxxxxx
   12
   1
   open Array
   2
   let n = read_int () 
   3
   let f t =  Float.sqrt (Float.abs t) +. 5. /. (t -. 10.)
   4
   let strange n = if n mod 3 = n mod 5 then n*2 else n-1
   5
   let a = init n (fun _ -> read_float ())  
   6
   let () =
   7
     for i = strange n downto 0 do
   8
       let msg =
   9
         let y = f a.(i) in
   10
         if y <= 400. then (string_of_float y) else  "TOO LARGE" in
   11
       print_endline msg
   12
     done
   

   Grave este programa em fich.ml e compile este programa por forma a que seja instrumentado pela ferramenta afl :

   xxxxxxxxxx
   1
   1
   $ ocamlopt -afl-instrument fich.ml -o strange
   

    

3. Prepare a execução de afl :

   xxxxxxxxxx
   2
   1
   $ mkdir input
   2
   $ mkdir output
   

   Coloque o ficheiro testecase com o conteúdo

   xxxxxxxxxx
   12
   1
   11
   2
   -1
   3
   54
   4
   2
   5
   73
   6
   4
   7
   100
   8
   466
   9
   400
   10
   10000
   11
   -76
   12
   39
   

   na pasta input.

4. Execute a ferramenta afl sobre o binário para a sua descoberta de inputs que causam quebra da execução :

   xxxxxxxxxx
   1
   1
   $ afl-fuzz -i input -o output ./strange
   

   Tenha em atenção que a ferramenta afl vai gerar casos de teste a partir do exemplo dado (no ficheiro testcase). A procura poderá demorar tempo. Quando o contador uniq crashes apresentado na interface passar do $0$$0$, por exemplo uniq crashes : 1 , isso significará que a ferramenta encontrou um teste que provoca o fim abruto da execução. Neste caso aqui vários motivos para crashes são detetados, $4$$4$ pelo menos. Poderá aqui interromper a execução carregando em Ctrl-c.

   Após o término da sua execução, analise os ficheiro presentes na pasta output onde o afl colocou o resultado da sua análise. Em particular os ficheiros presentes na pasta crashes. Consegue perceber que falhas foram expostas?