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); }