ZEND_API int zend_ts_hash_compare(TsHashTable *ht1, TsHashTable *ht2, compare_func_t compar, zend_bool ordered)
{
int retval;
begin_read(ht1);
begin_read(ht2);
retval = zend_hash_compare(TS_HASH(ht1), TS_HASH(ht2), compar, ordered);
end_read(ht2);
end_read(ht1);
return retval;
}
int
open_wim_as_WIMStruct(const void *wim_filename_or_fd, int open_flags,
WIMStruct **wim_ret,
wimlib_progress_func_t progfunc, void *progctx)
{
WIMStruct *wim;
int ret;
ret = wimlib_global_init(WIMLIB_INIT_FLAG_ASSUME_UTF8);
if (ret)
return ret;
wim = new_wim_struct();
if (!wim)
return WIMLIB_ERR_NOMEM;
wim->progfunc = progfunc;
wim->progctx = progctx;
ret = begin_read(wim, wim_filename_or_fd, open_flags);
if (ret) {
wimlib_free(wim);
return ret;
}
*wim_ret = wim;
return 0;
}
void end_read(const boost::system::error_code &ec, std::size_t bytes_transferred)
{
if (!ec)
{
pending_read_buffer_ += std::string(read_buffer_.data(), bytes_transferred);
while (pending_read_buffer_.size() > sizeof(inotify_event))
{
const inotify_event *iev = reinterpret_cast<const inotify_event*>(pending_read_buffer_.data());
dir_monitor_event::event_type type = dir_monitor_event::null;
switch (iev->mask)
{
case IN_CREATE: type = dir_monitor_event::added; break;
case IN_DELETE: type = dir_monitor_event::removed; break;
case IN_MODIFY: type = dir_monitor_event::modified; break;
case IN_MOVED_FROM: type = dir_monitor_event::renamed_old_name; break;
case IN_MOVED_TO: type = dir_monitor_event::renamed_new_name; break;
case IN_CREATE | IN_ISDIR:
{
type = dir_monitor_event::added;
add_directory(get_dirname(iev->wd) + "/" + iev->name);
break;
}
}
pushback_event(dir_monitor_event(boost::filesystem::path(get_dirname(iev->wd)) / iev->name, type));
pending_read_buffer_.erase(0, sizeof(inotify_event) + iev->len);
}
begin_read();
}
else if (ec != boost::asio::error::operation_aborted)
{
boost::system::system_error e(ec);
boost::throw_exception(e);
}
}
int ft_read(t_env **env, t_data *environ)
{
t_hist *hst;
t_edit *lst_e;
char *key;
hst = NULL;
lst_e = NULL;
key = (char *)malloc(sizeof(char) * 7);
ft_bzero(key, 7);
if (ft_sigleton(0) != 3)
begin_read(&hst, &lst_e, environ);
while (!ENTER && ft_sigleton(0) != 3)
{
if (in_while(&key, env, &hst, &lst_e) == -1)
{
free(key);
return (-2);
}
}
if (after_while(env, environ, &lst_e, &hst) == 1)
{
free(key);
return (0);
}
return (0);
}
char *ft_read_htdoc(t_env **env, t_data *environ)
{
char *str;
t_hist *hst;
t_edit *lst_e;
char *key;
hst = NULL;
lst_e = NULL;
key = (char *)malloc(sizeof(char) * 7);
ft_bzero(key, 7);
begin_read(&hst, &lst_e, environ);
while (!ENTER && ft_sigleton(0) != 3)
{
if (in_while(&key, &environ, &hst, &lst_e) == -1)
{
free(key);
return (NULL);
}
}
if ((str = after_while(env, environ, &lst_e, &hst)))
{
free(key);
return (str);
}
return (NULL);
}
void simple_kv_client_app::run()
{
int id;
std::string key;
std::string value;
int timeout_ms;
rpc_address receiver;
dsn::replication::config_type::type type;
rpc_address node;
while (!g_done)
{
if (test_case::fast_instance().check_client_write(id, key, value, timeout_ms))
{
begin_write(id, key, value, timeout_ms);
continue;
}
if (test_case::fast_instance().check_replica_config(receiver, type, node) )
{
send_config_to_meta(receiver, type, node);
continue;
}
if (test_case::fast_instance().check_client_read(id, key, timeout_ms))
{
begin_read(id, key, timeout_ms);
continue;
}
test_case::fast_instance().wait_check_client();
}
}
ZEND_API void zend_ts_hash_merge_ex(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, merge_checker_func_t pMergeSource, void *pParam)
{
begin_read(source);
begin_write(target);
zend_hash_merge_ex(TS_HASH(target), TS_HASH(source), pCopyConstructor, pMergeSource, pParam);
end_write(target);
end_read(source);
}
void end_read(const boost::system::error_code &ec, std::size_t bytes_transferred)
{
if (!ec)
{
std::cout << std::string(buffer.data(), bytes_transferred) << std::flush;
begin_read();
}
}
ZEND_API void zend_ts_hash_merge(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, int overwrite)
{
begin_read(source);
begin_write(target);
zend_hash_merge(TS_HASH(target), TS_HASH(source), pCopyConstructor, overwrite);
end_write(target);
end_read(source);
}
ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key)
{
int retval;
begin_read(ht);
retval = zend_hash_exists(TS_HASH(ht), key);
end_read(ht);
return retval;
}
ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, zend_ulong h)
{
zval *retval;
begin_read(ht);
retval = zend_hash_index_find(TS_HASH(ht), h);
end_read(ht);
return retval;
}
ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key)
{
zval *retval;
begin_read(ht);
retval = zend_hash_find(TS_HASH(ht), key);
end_read(ht);
return retval;
}
ZEND_API int zend_ts_hash_index_exists(TsHashTable *ht, zend_ulong h)
{
int retval;
begin_read(ht);
retval = zend_hash_index_exists(TS_HASH(ht), h);
end_read(ht);
return retval;
}
ZEND_API zval *zend_ts_hash_str_find(TsHashTable *ht, const char *key, size_t len)
{
zval *retval;
begin_read(ht);
retval = zend_hash_str_find(TS_HASH(ht), key, len);
end_read(ht);
return retval;
}
ZEND_API int zend_ts_hash_num_elements(TsHashTable *ht)
{
int retval;
begin_read(ht);
retval = zend_hash_num_elements(TS_HASH(ht));
end_read(ht);
return retval;
}
ZEND_API zval *zend_ts_hash_minmax(TsHashTable *ht, compare_func_t compar, int flag)
{
zval *retval;
begin_read(ht);
retval = zend_hash_minmax(TS_HASH(ht), compar, flag);
end_read(ht);
return retval;
}
int main()
{
bp::child c = start_child();
bp::pistream &is = c.get_stdout();
in.assign(is.handle().release());
begin_read();
io_service.run();
c.wait();
}
int list_exists(struct linked_list_head *list, int val) {
struct linked_list *p;
begin_read(list->sync);
p=list->head;
while (p) {
if (p->nb==val) {
end_read(list->sync);
return 1;
}
p=p->next;
}
end_read(list->sync);
return 0;
}
int exists(struct linked_list_head *list, int val) {
struct linked_list *p;
begin_read(&list->sync);
sleep(rand()%3 + 1);
p = list->head;
while(p != NULL) {
if (p->nb == val) {
end_read(&list->sync);
return 1;
}
p = p->next;
}
end_read(&list->sync);
return 0;
}
/* Loop reading + processing Ensemble upcalls.
*/
static void hot_mainloop(void *arg) {
hot_contextID_t id;
hot_cbType_t cb;
while (1) {
begin_read() ; {
read_contextID(&id);
trace("CALLBACK: group ID: %d", id);
read_cbType(&cb);
trace("CALLBACK: callback type: %d", cb);
if (cb > CB_EXIT)
hot_sys_Panic("bad callback type (%d)", cb);
(*(callback[cb]))(id, &cb);
} end_read () ;
}
}
void commit(size_t plane_index)
{
if(plane_index >= buffers_.size())
return;
auto buffer = std::move(buffers_[plane_index]); // Release buffer once done.
if(!buffer)
return;
auto texture = textures_.at(plane_index);
ogl_->begin_invoke([=]
{
buffer->unmap();
buffer->bind();
texture->begin_read();
buffer->unbind();
}, high_priority);
}
void *lecteur(void *args) {
donnees_thread_t *d = args;
int i, valeur;
srandom((int) pthread_self());
for (i=0; i < d->iterations; i++) {
dodo(2);
begin_read(d->lecteur_redacteur);
printf("Thread %x : début lecture\n", (int) pthread_self());
valeur = d->donnee;
dodo(1);
printf("Thread %x : ", (int) pthread_self());
if (valeur != d->donnee)
printf("LECTURE INCOHERENTE !!!\n");
else
printf("lecture cohérente\n");
end_read(d->lecteur_redacteur);
}
pthread_exit(0);
}
ZEND_API void zend_ts_hash_copy_to_hash(HashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor)
{
begin_read(source);
zend_hash_copy(target, TS_HASH(source), pCopyConstructor);
end_read(source);
}
