Question

I am developping a small Anti-Missile Simulator for a Class Project.

The Idea is to have different processes/threads comunicating with each other.

I started working on the Missile Laucher application. Its missile has to be a thread.

So this is the start code I made:

open Missile;;

(* Name of the Station *)
let launcher_name = "Pacific";;

(* Gravitational Constant *)
let g = 9.8;;

(* Temporal Reference *)
let time = ref 0.0;;

(* Calculates the next position in time of the missile *)
let calculate_position () = 
  let nX = 10.0 *. !time and nY = (0.5) *. g**2.0 in (nX,nY);;

(* Launches the thread missile and updates its position *)
let launch mis = 
  while true do 

    let pos = mis#position () in 
    Printf.printf "%s\n" pos;


    let (a,b) = calculate_position () in
    mis#moveto (a,b);
    time := !time +. 1.0;

    (* Why isnt this working? *)
    Thread.delay 0.25 

  done;;



(* test function *)
let launchMissile () = 
  Printf.printf "Launch Station %s launched a missile. \n" launcher_name;
  let mis  = new missile "Test" 1 "USA" in
  let t1 = Thread.create launch mis in
  Thread.join t1;;



launchMissile ();;

After doing this I wanted to test my CalculatePosition function by printing the values over time.

But without a pause or wait they print out too fast, obviously. So I thought about delay the thread 0.25 s in each of the while iteration.

What am I doing wrong? I tried so many different things. Its only the Thread.delay function that it is behaving strange.

Can I do this ?

If you could help it would be great, I have ran out of thought on this… and started rereading all the books I have here on Ocaml.

If it is also important for you to analyze the problem here is my Missile Class:

class missile name id owner = 
object
  val mutable name = name;
  val id = id;
  val owner = owner;
  val mutable x:float = 0.0
  val mutable y:float = 0.0
  method get_x = x
  method get_y = y
  method get_point = (x,y)
  method moveto (a,b) = x <- a; y <- b
  method rmoveto (dx, dy) = x <- x +. dx ; y <- y +. dy
  method to_string () = "( " ^ "I am Missile " ^ (string_of_int id) ^ " and my owner is   " ^ (owner) ^ ")";
  method position () = "(" ^ (string_of_float x) ^ "," ^ (string_of_float y) ^ ")";
  method distance () = sqrt (x*.x +. y*.y)
end;;

Thank you

Answer 1

Printf.* functions are buffered (because of formatting features I suppose), while print_* and prerr_* are not. If you replace your printf by print_endline, you will see your output happening as expected, without having to flush the buffers.

So this has nothing to do with buffer contentions or concurrent accesses as I originally stated, but just plain internal (not system) buffering.

A few remarks in passing : you don’t need to put semi-colon at the end of methods (though the grammar accepts it). Also, parentheses around expressions are superfluous between ^ operators. Both are a matter of style I guess.

Enjoy OCaml!