[simgrid.git] / src / bindings / ruby / simgrid.rb

#  Task-related bindings to ruby  */
# 
#  Copyright 2010. The SimGrid Team. All right reserved. */
# 
# This program is free software; you can redistribute it and/or modify it
#  under the terms of the license (GNU LGPL) which comes with this package. */
# # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # # 
require 'simgrid_ruby'
require 'thread'

##########################################################
# Class Semaphore 
##########################################################
class MySemaphore
   Thread.abort_on_exception = true
    attr_accessor :permits

  def initialize (permits = 0)
       @permits = permits
  end
  
  def acquire(mutex,cv)

    raise "Interrupted Thread " if (!Thread.current.alive?)
    mutex.synchronize {
    while @permits <= 0
       
       cv.wait(mutex)
       
    end
    @permits = @permits - 1
    cv.signal
    }
    
  end
    
  def release(mutex,cv)
    mutex.synchronize{
      @permits += 1
      cv.signal
      }
  end  
end
#######################################
# Another Semaphore
#######################################

class Semaphore
  def initialize(initvalue = 0)
    @counter = initvalue
    @waiting_list = []
  end

  def acquire
    Thread.critical = true
    if (@counter -= 1) < 0
      MSG::debug(Thread.current.to_s+" acquires "+self.to_s+". That's blocking.")
      @waiting_list.push(Thread.current)
      Thread.stop
    else
      MSG::debug(Thread.current.to_s+" acquires "+self.to_s+". It was free.")      
    end
    self
  ensure
    Thread.critical = false
  end

  def release
    Thread.critical = true
    begin
      if (@counter += 1) <= 0
        t = @waiting_list.shift
        t.wakeup if t
        MSG::debug(Thread.current.to_s+" releases "+self.to_s+". Wakeup "+t.to_s)
      else 
        MSG::debug(Thread.current.to_s+" releases "+self.to_s+". Nobody to wakeup")
      end
    rescue ThreadError
      retry
    end
    self
  ensure
    Thread.critical = false
  end
end

########################################################################
# Class Process 
########################################################################
class MSG::Process < Thread 
  @@nextProcessId = 0

# Attributes
  attr_reader :name, :pargs ,:properties, :cv, :mutex   # Read only
  
    def initialize(*args)
      super(){
        
     raise "Bad number of arguments to create a Ruby process. Expected (name,args,prop) " if args.size < 3
     
    @cv = ConditionVariable.new
    @mutex = Mutex.new
    @schedBegin = MySemaphore.new(0)
    @schedEnd = MySemaphore.new(0)    
    @id = @@nextProcessId
    @@nextProcessId +=1
    @name = args[0]
    @pargs = args[1]
    @properties = args[2]
      
    start()
      }
    end
    
  def main(args) 
    # To be overriden by childs
    raise("You must define a main() function in your process, containing the code of this process")
  end
     
  def start()
     @schedBegin.acquire(@mutex,@cv)

    MSG::debug("Let's execute the main() of the Ruby process")
    main(@pargs)
<<<<<<< .mine
#     processExit(self) # FIXME : Fix the simix_context_ruby_stop to stop context process before quitting
    @schedEnd.release(@mutex,@cv)
    
=======
    @schedEnd.release()
>>>>>>> .r7205
    MSG::debug("Released my schedEnd, bailing out")
    processExit(self) # Exit the Native Process
  end
    
  def getBind()
    return @bind
  end
   
  def setBind(bind)
    @bind = bind
  end
    
  def unschedule()
    @schedEnd.release(@mutex,@cv)
    @schedBegin.acquire(@mutex,@cv)
  end
  
  def schedule()   
    @schedBegin.release(@mutex,@cv)
    @schedEnd.acquire(@mutex,@cv)
  end
  
  def pause()
    processSuspend(self)
  end
  
  def restart()
    processResume(self)
  end
  
  def isSuspended()
    processIsSuspended(self)
  end
  
  def getHost()
    processGetHost(self)
  end
  
# The Rest of Methods !!! To be Continued ... FIXME: what's missing?
end

############################################
# Task Extend from the native Class RbTask
############################################
class MSG::Task < MSG::RbTask

  def initialize(*args)
     super()
  end
  
  def name
     super(self)
  end
  
  def compSize
     super(self)
  end
  
  def send(mailbox)
    super(self,mailbox)
  end
  

  def source
    super(self)
  end
  
  def sender
    super(self)
  end
  
  def listen(t_alias)
    super(t_alias)
  end
  
  def execute
    super(self)
  end
    
  def listenFromHost(t_alias,host)
    super(t_alias,host)
  end
end  

####################################################
# Host Extend from the native Class RbHost
####################################################
class MSG::Host < MSG::RbHost

  def getByName(name)
    super(name)
  end
  
  def name
    super(self)
  end
  
  def speed
    super(self)
  end
  
  def getData
    super(self)
  end
  
  def setData(data)
    super(self,data)
  end
  
  def isAvail
    super(self)
  end
  
  def number
    super()
  end
end

#########################
# Main chunck 
#########################
MSG.init(ARGV)