X-Git-Url: http://info.iut-bm.univ-fcomte.fr/pub/gitweb/simgrid.git/blobdiff_plain/b3d9680ac65d8bdd8e267aed69fc32a5abab12d7..7bcd4cc9d936caa1d23579f7aca67e68fade2a36:/src/bindings/ruby/simgrid.rb diff --git a/src/bindings/ruby/simgrid.rb b/src/bindings/ruby/simgrid.rb index 90b8793591..c618f33a61 100644 --- a/src/bindings/ruby/simgrid.rb +++ b/src/bindings/ruby/simgrid.rb @@ -1,416 +1,228 @@ +# 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' -include MSG require 'thread' -$DEBUG = true # This is a Global Variable Useful for Debugging +####################################### +# Semaphore +####################################### -########################################################################### -# Class Semaphore -########################################################################### -class Semaphore - Thread.abort_on_exception = true - attr_accessor :permits - - def initialize ( permits ) - @permits = permits +class Semaphore + def initialize(initvalue = 0) + @counter = initvalue + @waiting_list = [] end - - def acquire(mutex,cv) - raise "Interrupted Thread " if (!Thread.current.alive?) - mutex.synchronize { - while @permits <= 0 - cv.wait(mutex) + 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 - - @permits = @permits - 1 - cv.signal - } - end - - def release(mutex,cv) - mutex.synchronize{ - @permits += 1 - cv.signal - } + rescue ThreadError + retry + end + self + ensure + Thread.critical = false end end ######################################################################## -# Class RbProcess +# Class Process ######################################################################## -class RbProcess < Thread +class MSG::Process < Thread @@nextProcessId = 0 + # Attributes - attr_accessor :bind, :id, :properties, :name, - :pargs, :schedBegin, :schedEnd, :mutex, :cv + attr_reader :name, :pargs ,:properties # Read only -# Initialize : Used from ApplicationHandler to fill it in - def initialize(*args) - - argc = args.size - - if argc == 0 # Default initializer - super() { - @id = 0 - @bind = 0 - @name = "" - @pargs = Array.new() - init_var() - start() - if $DEBUG - puts "Init Default Initializer...Nothing to do...Bye" - end - } - - # 2 arguments: (HostName,Name) Or (Host , Name) - elsif argc == 2 - super(){ - type = args[0].type() - if ( type.to_s == "String") - host = Host.getByName(args[0]) - elsif ( type.to_s == "MSG::Host") - host = args[0] - else - raise "first argument of type "+args[0].type().to_s+", but expecting either String or MSG::Host" - end - if $DEBUG - puts host - end - raise "Process name cannot be null" if args[1].empty? - @name = args[1] - if $DEBUG - puts @name - end - @pargs = Array.new() # No Args[] Passed in Arguments - @@nextProcessId += 1 - @id = @@nextProcessId - init_var() - start() - createProcess(self,host) - if $DEBUG - puts "Initilize with 2 args" - end - } - - # 3 arguments: (hostName,Name,args[]) or (Host,Name,args[]) - elsif argc == 3 + def initialize(*args) super(){ - type = args[0].type() - if ( type.to_s == "String") - host = Host.getByName(args[0]) - elsif ( type.to_s == "MSG::Host") - host = args[0] - else - raise "first argument of type "+args[0].type().to_s+", but expecting either String or MSG::Host" - end - if $DEBUG - puts host - end - - raise "Process name cannot be null" if args[1].empty? - @name = args[1] - type = args[2].type() - raise "Third argument should be an Array" if type != "Array" - @pargs = args[3] - @@nextProcessId +=1 - @id = @@nextProcessId - init_var() - createProcess(self,host) - - if $DEBUG - puts "Initilize with 3 args" - end - -# sleep #keep the thread running - } - else - raise "Bad number of argument: Expecting either 1, 2 or 3, but got "+argc - end - end - - # Init_var Called By Initialize - def init_var() - @proprieties = Hash.new() - @mutex = Mutex.new - @cv = ConditionVariable.new - # Process Synchronization Tools + + raise "Bad number of arguments to create a Ruby process. Expected (name,args,prop) " if args.size < 3 + @schedBegin = Semaphore.new(0) @schedEnd = Semaphore.new(0) - end - - #main - def msg_main(args) - # To Be Implemented within The Process... - # The Main Code of The Process to be Executed ... + @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 - # Start : To keep the Process Alive and waitin' via semaphore def start() - @schedBegin.acquire(@mutex,@cv) - #execute The Main Code of The Process ( Example Master ; Slave ...) - msg_main(@pargs) - processExit(self) #Exite the Native Process - @schedEnd.release(@mutex,@cv) - end + @schedBegin.acquire + MSG::debug("Let's execute the main() of the Ruby process") + main(@pargs) + @schedEnd.release + MSG::debug("Released my schedEnd, bailing out") + processExit(self) # Exit the Native Process -# NetxId - def nextId () - @@nextProcessId +=1 - return @@nextProcessId - end - - if $DEBUG - #Process List - def processList() - Thread.list.each {|t| p t} - end - end - - #Get Own ID - def getID() - return @id end - - # set Id - def setID(id) - @id = id - end - - #Get a Process ID - def processID(process) - return process.id - end - - #Get Own Name - def getName() - return @name - end - - #Get a Process Name - def processName(process) - return process.name - end - - #Get Bind + def getBind() return @bind end - - #Get Binds + def setBind(bind) @bind = bind end - def unschedule() - - @schedEnd.release(@mutex,@cv) -# info("@schedEnd.release(@mutex,@cv)") - @schedBegin.acquire(@mutex,@cv) -# info("@schedBegin.acquire(@mutex,@cv)") - + def unschedule() + @schedEnd.release + @schedBegin.acquire end - def schedule() - @schedBegin.release(@mutex,@cv) - @schedEnd.acquire(@mutex,@cv) + def schedule() + @schedBegin.release + @schedEnd.acquire end - #C Simualateur Process Equivalent Management - # After Binding Ruby Process to C Process - -# pause def pause() processSuspend(self) end -# restart def restart() processResume(self) end -# isSuspended def isSuspended() processIsSuspended(self) end -# getHost def getHost() processGetHost(self) end - -# The Rest of Methods !!! To be Continued ... -end - -######################################################################## -# Class ProcessFactory -######################################################################## -class ProcessFactory - -# Attributes - attr_accessor :args, :proprieties, :hostName, :function -# Initlialize - def initialize() - - @args = Array.new - @proprieties = Hash.new - @hostName = nil - @function = nil - - end - -# setProcessIdentity - def setProcessIdentity(hostName,function) - @hostName = hostName - @function = function - - if !args.empty? - args.clear - end - - if !proprieties.empty? - proprieties.clear - end - - end - -# RegisterProcess - def registerProcessArg(arg) - - @args.push(arg) - - end - -# CreateProcess - def createProcess() - - process = rubyNewInstance(@function) # process = rubyNewInstanceArgs(@function,@args) # - size = @args.size - for i in 0..size-1 - process.pargs.push(@args[i]) - end - process.name = @function - process.id = process.nextId() # This increment Automaticaly The Static ProcessNextId for The Class RbProces - host = RbHost.getByName(@hostName) - processCreate(process,host) - process.properties = @properties - @proprieties = Hash.new - - end - -# SetProperty - def setProperty(id,value) - @proprieties[id] = value - 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 -######################################################################### -# Class ApplicationHandler -######################################################################### -class ApplicationHandler - @processFactory -# Initialize - def initialize() - #Nothing todo + def initialize(*args) + super() end - # onStartDocument - def onStartDocument() - - @processFactory = ProcessFactory.new - if ($DEBUG) - puts "onStartDocument" - end - + def setData(value) + super(self,value) end -# onBeginProcess - def onBeginProcess(hostName,function) - - @processFactory.setProcessIdentity(hostName,function) - - if ($DEBUG) - puts "onBeginProcess" - end - + def data() + super(self) end - -# onProperty - def onProperty(id,value) - - @processFactory.setProperty(id,value) - - if ($DEBUG) - puts "onProperty" - end - + + def name + super(self) end -# RegisterProcessArg - def onProcessArg(arg) - - @processFactory.registerProcessArg(arg) - - if ($DEBUG) - puts "onProcessArg" - 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 - -# OnEndProcess - def onEndProcess() - - @processFactory.createProcess() - - if ($DEBUG) - puts "onEndProcess" - end - - end - - # onEndDocument - def onEndDocument() -# Erm... Actually nothing to do !! - - if($DEBUG) - puts "onEndDocument" - end - end - - # End Class - end - -######################### -# Class RbHost -######################### - -class RbHost < Host -# Attributes - attr_accessor :bind, :data -# Initialize - def initialize() - super() - @bind = 0 - @data = nil + def setPriority(priority) + super(self,priority) end -end - -######################### -# Class RbTask -######################### -class RbTask < Task - attr_accessor :bind + def cancel() + super(self) + end - def initialize(name,comp_size,comm_size) - super(name,comp_size,comm_size) +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 + + def getHostProcess(process) + super(process) + end + end - ######################### # Main chunck ######################### -MSG.init(ARGV) +MSG.init(ARGV) \ No newline at end of file