1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
|
/* Copyright (C) 2014-2015 Timo Dritschler <timo.dritschler@kit.edu>
(Karlsruhe Institute of Technology)
This library is free software; you can redistribute it and/or modify it
under the terms of the GNU Lesser General Public License as published by the
Free Software Foundation; either version 2.1 of the License, or (at your
option) any later version.
This library is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
details.
You should have received a copy of the GNU Lesser General Public License along
with this library; if not, write to the Free Software Foundation, Inc., 51
Franklin St, Fifth Floor, Boston, MA 02110, USA
*/
/**
* SECTION: kiro-sync-buffer
* @Short_description: KIRO 'Synchronizing Buffer'
* @Title: KiroSb
*
* KiroSb implements a 'Synchronizing Buffer' that automatically keeps the local
* memory content up to date by mirroring the remote SyncBuffers memory content
* automatically without any required user interaction
*/
#ifndef __KIRO_SB_H
#define __KIRO_SB_H
#include <stdint.h>
#include <glib-object.h>
G_BEGIN_DECLS
#define KIRO_TYPE_SB (kiro_sb_get_type())
#define KIRO_SB(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), KIRO_TYPE_SB, KiroSb))
#define KIRO_IS_SB(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), KIRO_TYPE_SB))
#define KIRO_SB_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), KIRO_TYPE_SB, KiroSbClass))
#define KIRO_IS_SB_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), KIRO_TYPE_SB))
#define KIRO_SB_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), KIRO_TYPE_SB, KiroSbClass))
typedef struct _KiroSb KiroSb;
typedef struct _KiroSbClass KiroSbClass;
typedef struct _KiroSbPrivate KiroSbPrivate;
struct _KiroSb {
GObject parent;
};
/**
* IbvConnectorInterface:
*
* Base interface for IbvConnectors.
*/
struct _KiroSbClass {
GObjectClass parent_class;
};
/* GObject and GType functions */
/**
* kiro_sb_get_type: (skip)
* Returns: GType of #KiroSb
*/
GType kiro_sb_get_type (void);
/**
* kiro_sb_new - Creates a new #KiroSb
* Returns: (transfer full): A pointer to a new #KiroSb
* Description:
* Creates a new #KiroSb and returns a pointer to it.
* See also:
* kiro_sb_free
*/
KiroSb* kiro_sb_new (void);
/**
* kiro_sb_free - 'Destroys' the given #KiroSb
* @trb: (transfer none): The #KiroSb that is to be freed
* Description:
* Clears all underlying memory and frees the object memory.
* Note:
* The internal memory is also freed when calling this function. If you want
* to continue using the raw @sb memory after you call this function, you need
* to memcpy() its content using the information optained from
* kiro_sb_get_element()
* See also:
* kiro_sb_new, kiro_sb_get_element
*/
void kiro_sb_free (KiroSb *sb);
/**
* kiro_sb_serve - Allow remote KiroSbs to clone this buffers memory
* Returns: A gboolean. TRUE = success. FALSE = fail.
* @sb: (transfer none): The #KiroSb to perform this operation on
* @size: Size in bytes of the content that will be served
* Description:
* Allows other remote #KiroSbs to connect to this #KiroSb and clone its
* memory.
* Note:
* A #KiroSb that already 'serves' its content can no longer clone
* other remote #KiroSbs.
* See also:
*
*/
gboolean kiro_sb_serve (KiroSb *sb, gulong size);
/**
* kiro_sb_clone - Clone the content of a remote #KiroSb
* Returns: A gboolean. TRUE = connection successful. FALSE = connection failed.
* @sb: (transfer none): The #KiroSb to perform this operation on
* @address: The InfiniBand address of the remote #KiroSb which should be cloned
* @port: The InfiniBand port of the remote #KiroSb which should be cloned
* Description:
* Connects to the remote #KiroSb given by @address and @port and
* continuousely clones its content into the local #KiroSb
* Note:
* A #KiroSb that clones a remote #KiroSb can no longer start to 'serve' its
* content to other remote #KiroSbs
* See also:
*
*/
gboolean kiro_sb_clone (KiroSb *sb, const gchar *address, const gchar *port);
/**
* kiro_sb_get_size - Get the size in bytes of the managed memory
* Returns: A gulong giving the size of the managed memory in bytes
* @sb: (transfer none): The #KiroSb to perform this operation on
* Description:
* Returns the size in bytes of the content that is being served and/or cloned
* from.
* Note:
* Since #KiroSb uses an internal triple buffer, the value gained from this
* function only gives the size of one element from that buffer. The size of
* the entire data structure will be different.
* See also:
*
*/
gulong kiro_sb_get_size (KiroSb *sb);
G_END_DECLS
#endif //__kiro_sb_H
|
