Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
Merge branch 'hypervisor' of git+ssh://scm.gforge.inria.fr//gitroot/simgrid/simgrid...
authorPaul Bédaride <paul.bedaride@gmail.com>
Thu, 6 Jun 2013 21:33:40 +0000 (23:33 +0200)
committerPaul Bédaride <paul.bedaride@gmail.com>
Thu, 6 Jun 2013 21:33:40 +0000 (23:33 +0200)
ChangeLog
buildtools/Cmake/DefinePackages.cmake
doc/doxygen/module-msg.doc
include/msg/msg.h
src/bindings/java/jmsg_synchro.c
src/bindings/java/org/simgrid/msg/Semaphore.java [new file with mode: 0644]
src/msg/msg_synchro.c [new file with mode: 0644]
src/surf/surf_routing_dijkstra.c
src/xbt/log.c

index 2f30967..eff9d76 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -11,6 +11,11 @@ SimGrid (3.10) NOT RELEASED; urgency=low
  * Bugfix: Task.setDataSize() only changed the C world, not the value
    cached in the Java world
 
+ MSG:
+ * Dramatically change the way files are handled. API and internals changed, but
+   this part of MSG was not considered as production grade either.
+ * Add explicit synchronization facilities through semaphores
+
  SMPI:
  * SMPI is not built as a separate library anymore, it's now included in
    libsimgrid.
index 4e42ec5..10c1f03 100644 (file)
@@ -323,6 +323,7 @@ set(MSG_SRC
   src/msg/msg_io.c
   src/msg/msg_mailbox.c
   src/msg/msg_process.c
+  src/msg/msg_synchro.c
   src/msg/msg_task.c
   src/msg/msg_vm.c
   )
@@ -423,6 +424,7 @@ set(JMSG_JAVA_SRC
   src/bindings/java/org/simgrid/msg/Msg.java
   src/bindings/java/org/simgrid/msg/MsgException.java
   src/bindings/java/org/simgrid/msg/Mutex.java
+  src/bindings/java/org/simgrid/msg/Semaphore.java
   src/bindings/java/org/simgrid/msg/NativeException.java
   src/bindings/java/org/simgrid/msg/Process.java
   src/bindings/java/org/simgrid/msg/ProcessKilledError.java
index 2241a15..d652b97 100644 (file)
@@ -29,6 +29,7 @@ us before digging into these badly documented internal modules).
    - \ref msg_file_management
    - \ref msg_task_usage
    - \ref msg_VMs
+   - \ref msg_synchro
    - \ref msg_trace_driven
    - \ref MSG_examples
    - \ref msg_deprecated_functions
@@ -92,6 +93,14 @@ details).
  *         by a process to execute, communicate or otherwise handle some task.
  */
 
+/** @defgroup msg_synchro Explicit Synchronization Functions
+ *  @ingroup MSG_API
+ *  @brief This section describes several explicit synchronization
+ *         mechanisms existing in MSG: semaphores (#msg_sem_t) and friends.
+ *
+ * In some situations, these things are very helpful to synchronize processes without message exchanges.
+ */
+
 /** @defgroup msg_VMs VMs
  *  @ingroup MSG_API
  *  @brief This section describes the interface created to mimic IaaS clouds.
index 16ca784..154fc39 100644 (file)
@@ -365,6 +365,19 @@ XBT_PUBLIC(msg_error_t) MSG_set_channel_number(int number);
 XBT_PUBLIC(int) MSG_get_channel_number(void);
 #endif
 
+/** @brief Opaque type representing a semaphore
+ *  @ingroup msg_synchro
+ *  @hideinitializer
+ */
+typedef struct s_smx_sem *msg_sem_t; // Yeah that's a rename of the smx_sem_t which doesnt require smx_sem_t to be declared here
+XBT_PUBLIC(msg_sem_t) MSG_sem_init(int initial_value);
+XBT_PUBLIC(void) MSG_sem_acquire(msg_sem_t sem);
+XBT_PUBLIC(msg_error_t) MSG_sem_acquire_timeout(msg_sem_t sem, double timeout);
+XBT_PUBLIC(void) MSG_sem_release(msg_sem_t sem);
+XBT_PUBLIC(void) MSG_sem_get_capacity(msg_sem_t sem);
+XBT_PUBLIC(void) MSG_sem_destroy(msg_sem_t sem);
+XBT_PUBLIC(int) MSG_sem_would_block(msg_sem_t sem);
+
 /** @brief Opaque type describing a Virtual Machine.
  *  @ingroup msg_VMs
  *
index cbccf4c..21c04d7 100644 (file)
@@ -56,3 +56,52 @@ Java_org_simgrid_msg_Mutex_exit(JNIEnv * env, jobject obj) {
   mutex = (xbt_mutex_t) (long) (*env)->GetLongField(env, obj, jsyncro_field_Mutex_bind);
   xbt_mutex_destroy(mutex);
 }
+
+static jfieldID jsyncro_field_Semaphore_bind;
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Semaphore_nativeInit(JNIEnv *env, jclass cls) {
+  jsyncro_field_Semaphore_bind = jxbt_get_sfield(env, "org/simgrid/msg/Semaphore", "bind", "J");
+  if (!jsyncro_field_Semaphore_bind) {
+    jxbt_throw_native(env,bprintf("Can't find some fields in Semaphore Java class. You should report this bug."));
+  }
+}
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Semaphore_init(JNIEnv * env, jobject obj, jint capacity) {
+  msg_sem_t sem = MSG_sem_init((int) capacity);
+
+  (*env)->SetLongField(env, obj, jsyncro_field_Semaphore_bind, (jlong) (long) (sem));
+}
+
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Semaphore_acquire(JNIEnv * env, jobject obj, jdouble timeout) {
+  msg_sem_t sem;
+
+  sem = (msg_sem_t) (long) (*env)->GetLongField(env, obj, jsyncro_field_Semaphore_bind);
+  msg_error_t res = MSG_sem_acquire_timeout(sem, (double) timeout);
+  jmsg_throw_status(env, res);
+}
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Semaphore_release(JNIEnv * env, jobject obj) {
+  msg_sem_t sem;
+
+  sem = (msg_sem_t) (long) (*env)->GetLongField(env, obj, jsyncro_field_Semaphore_bind);
+  MSG_sem_release(sem);
+}
+JNIEXPORT jboolean JNICALL
+Java_org_simgrid_msg_Semaphore_wouldBlock(JNIEnv * env, jobject obj) {
+  msg_sem_t sem;
+
+  sem = (msg_sem_t) (long) (*env)->GetLongField(env, obj, jsyncro_field_Semaphore_bind);
+  int res = MSG_sem_would_block(sem);
+  return (jboolean) res;
+}
+
+JNIEXPORT void JNICALL
+Java_org_simgrid_msg_Mutex_destroy(JNIEnv * env, jobject obj) {
+  msg_sem_t sem;
+
+  sem = (msg_sem_t) (long) (*env)->GetLongField(env, obj, jsyncro_field_Semaphore_bind);
+  MSG_sem_destroy(sem);
+}
diff --git a/src/bindings/java/org/simgrid/msg/Semaphore.java b/src/bindings/java/org/simgrid/msg/Semaphore.java
new file mode 100644 (file)
index 0000000..f1a276b
--- /dev/null
@@ -0,0 +1,86 @@
+/* 
+ * Copyright 2012 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.
+ *
+ */
+package org.simgrid.msg;
+/** A semaphore implemented on top of SimGrid synchronization mechanisms. 
+ * You can use it exactly the same way that you use classical semaphores
+ * but to handle the interactions between the processes within the simulation.   
+ *
+ */
+
+public class Semaphore {
+    private long bind; // The C object -- don't touch it
+    /**
+     * Semaphore capacity, defined when the semaphore is created. At most capacity 
+     * process can acquire this semaphore at the same time.
+     */
+    protected final int capacity;
+    /**
+     * Creates a new semaphore with the given capacity. At most capacity 
+     * process can acquire this semaphore at the same time.
+     */
+    public Semaphore(int capacity) {
+       init(capacity);
+       this.capacity = capacity;
+    }
+    /** The native implementation of semaphore initialization
+     */
+    private native void init(int capacity);
+
+
+    /** Locks on the semaphore object until the provided timeout expires
+     * @exception TimeoutException if the timeout expired before 
+     *            the semaphore could be acquired.
+     */
+    public native void acquire(double timeout) throws TimeoutException;
+    /** Locks on the semaphore object with no timeout
+     */
+    public void acquire() {
+       try {
+           acquire(-1);
+       } catch (TimeoutException e) {
+           // This should not happen.
+           assert(false);
+       }
+    }
+    /** Releases the semaphore object
+     */
+    public native void release();
+    /** returns a boolean indicating it this semaphore would block at this very specific time
+     *
+     * Note that the returned value may be wrong right after the
+     * function call, when you try to use it...  But that's a
+     * classical semaphore issue, and SimGrid's semaphores are not
+     * different to usual ones here.
+     */
+    public native boolean wouldBlock();
+
+    /** Returns the semaphore capacity
+     */
+    public int getCapacity(){
+       return this.capacity;
+    }
+
+
+    /** Deletes this semaphore 
+     */
+    protected void finalize() {
+       destroy();
+    }
+    /** The native implementation for destroying a semaphore
+     */
+    private native void destroy();
+    /**
+     * Class initializer, to initialize various JNI stuff
+     */
+    public static native void nativeInit();
+    static {
+       Msg.nativeInit();
+       nativeInit();
+    }
+}
\ No newline at end of file
diff --git a/src/msg/msg_synchro.c b/src/msg/msg_synchro.c
new file mode 100644 (file)
index 0000000..f06e6bb
--- /dev/null
@@ -0,0 +1,66 @@
+/* Copyright (c) 2013 Da SimGrid Team. All rights 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. */
+
+#include "msg_private.h"
+#include "xbt/sysdep.h"
+#include "xbt/log.h"
+
+XBT_LOG_NEW_DEFAULT_SUBCATEGORY(msg_synchro, msg,
+                                "Logging specific to MSG (synchro)");
+
+
+/** @addtogroup msg_synchro
+ *
+ *  @{
+ */
+
+/********************************* Host **************************************/
+
+/** @brief creates a semaphore object of the given initial capacity */
+msg_sem_t MSG_sem_init(int initial_value) {
+  return simcall_sem_init(initial_value);
+}
+
+/** @brief locks on a semaphore object */
+void MSG_sem_acquire(msg_sem_t sem) {
+  simcall_sem_acquire(sem);
+}
+/** @brief locks on a semaphore object up until the provided timeout expires */
+msg_error_t MSG_sem_acquire_timeout(msg_sem_t sem, double timeout) {
+  xbt_ex_t e;
+  msg_error_t res = MSG_OK;
+  TRY {
+    simcall_sem_acquire_timeout(sem,timeout);
+  } CATCH(e) {
+    if (e.category == timeout_error) {
+      res = MSG_TIMEOUT;
+      xbt_ex_free(e);
+    } else {
+      RETHROW;
+    }
+  }
+  return res;
+}
+/** @brief releases the semaphore object */
+void MSG_sem_release(msg_sem_t sem) {
+  simcall_sem_release(sem);
+}
+void MSG_sem_get_capacity(msg_sem_t sem) {
+  simcall_sem_get_capacity(sem);
+}
+
+void MSG_sem_destroy(msg_sem_t sem) {
+  simcall_sem_destroy(sem);
+}
+/** @brief returns a boolean indicating it this semaphore would block at this very specific time
+ *
+ * Note that the returned value may be wrong right after the function call, when you try to use it...
+ * But that's a classical semaphore issue, and SimGrid's semaphore are not different to usual ones here.
+ */
+int MSG_sem_would_block(msg_sem_t sem) {
+  return simcall_sem_would_block(sem);
+}
+
+/**@}*/
index 4b0d4c9..d225cd4 100644 (file)
@@ -51,7 +51,7 @@ static void graph_node_map_elem_free(void *e)
   xbt_free(elm);
 }
 
-static void graph_edge_data_free(void *e) // FIXME: useless code dupplication
+static void graph_edge_data_free(void *e) // FIXME: useless code duplication
 {
   sg_platf_route_cbarg_t e_route = (sg_platf_route_cbarg_t) e;
   if (e_route) {
index a089714..0abd62b 100644 (file)
@@ -621,6 +621,7 @@ static void xbt_log_connect_categories(void)
   XBT_LOG_CONNECT(msg_mailbox);
   XBT_LOG_CONNECT(msg_new_API);
   XBT_LOG_CONNECT(msg_process);
+  XBT_LOG_CONNECT(msg_synchro);
   XBT_LOG_CONNECT(msg_task);
   XBT_LOG_CONNECT(msg_vm);