bluuebunny/crossref_metadata_2025_split huggingface dataset:
COMMUNITY ACQUIRED METHICILLIN RESISTANT STAPHYLOCOCCUS AUREUS HAND INFECTIONS: A SOUTH PACIFIC PERSPECTIVE — CHARACTERISTICS AND IMPLICATIONS FOR ANTIBIOTIC COVERAGE
Authors: Buchanan Derek , Heiss-Dunlop Wolfgang , Mathy Jon A. 
Published: October 2012

Purpose: Community acquired methicillin resistant Staphylococcus aureus (CA-MRSA) infections are reported to be increasing worldwide. In the United States when rates exceed 15% empiric treatment is suggested. The aim of our study was to determine local rates and treatment of CA-MRSA within our region. Methods: Nine hundred and forty-two patients were admitted to our service during a six-year period with culture-positive hand infections identified from operative cultures at the time of surgery. Results: Sixty-six (7.0%) patients had CA-MRSA positive cultures identified. Thirty-two (48.5%) patients were noted to have remained on antibiotic treatment that did not reflect their MRSA positive status after cultures returned. Despite this, re-admission and re-operation rates were low and comparable to our non-MRSA control group. Conclusions: Within our CA-MRSA group, current rates do not support automatic empiric treatment for CA-MRSA. Based on sensitivity data, co-trimoxazole and intravenous vancomycin are appropriate and effective antibiotic treatment within our region. Our data supports the importance of drainage of pyogenic infections in helping to resolve complicated hand infections.
THE BUTTON-OVER-NAIL TECHNIQUE FOR ZONE I FLEXOR TENDON INJURIES
Authors: Bidwai A. S. C. , Feldberg L. 
Published: October 2012

The "button over the nail" is the most commonly used technique in order to re-insert the flexor digitorum profundus tendon into the distal phalanx in the management of Zone 1 injuries. Recent evidence in the literature has highlighted an associated morbidity with the technique. In this study, 37 patients were identified that had been treated using the "button technique", for which outcome data is collected by hand therapists as part of a prospective flexor tendon injury audit. Retrospective case note review was performed to determine incidence of post-operative surgical complications. There were limited complications with the use of the "button technique" overall. However, functional outcome when compared to other studies are relatively poor with mean range of motion at the distal interphalangeal joint being 37.5 degrees. The authors would recommend any decision to change technique for the management of these injuries should consider functional outcome in the presence of a low surgical complication rate.
TRAUMATIC VOLAR DISLOCATION OF THE DISTAL ULNA WITH A FRACTURE OF THE ULNAR STYLOID
Authors: Sonohata Motoki , Mine Hiroko , Tsuruta Toshiyuki , Mawatari Masaaki 
Published: October 2012

Isolated volar dislocation of the distal ulna without forearm fracture is very rare; however, this injury is incorrectly diagnosed in approximately 50% of cases. This injury can lead to a significant functional disability if left untreated. This report presents a case of isolated volar dislocation of the distal ulna with an ulnar styloid fracture. The dislocation was subsequently reduced, the styloid was surgically repaired, and the patient was satisfied at the last follow-up. The importance of a proper clinical examination and an accurate radiographic position of the wrist are stressed. Furthermore, clinical evaluation of the distal radioular joint after reduction is important in achieving good results. There are various strategies for the treatment of distal radioulnar joint after reduction, including conservative treatment or surgical treatment. We believe that surgical exploration could have been carried out at an earlier stage had such a lesion been suspected. Additional case reports of other instances of successful treatment are needed to educate orthopaedic surgeons and emergency medical technicians on the nature of this type of injury.
Zyzzyva
Authors: Kotla Ramakrishna , Alvisi Lorenzo , Dahlin Mike , Clement Allen , Wong Edmund 
Published: October 2012

A longstanding vision in distributed systems is to build reliable systems from unreliable components. An enticing formulation of this vision is Byzantine Fault-Tolerant (BFT) state machine replication, in which a group of servers collectively act as a correct server even if some of the servers misbehave or malfunction in arbitrary (“Byzantine”) ways. Despite this promise, practitioners hesitate to deploy BFT systems, at least partly because of the perception that BFT must impose high overheads.
In this article, we present Zyzzyva, a protocol that uses speculation to reduce the cost of BFT replication. In Zyzzyva, replicas reply to a client's request without first running an expensive three-phase commit protocol to agree on the order to process requests. Instead, they optimistically adopt the order proposed by a primary server, process the request, and reply immediately to the client. If the primary is faulty, replicas can become temporarily inconsistent with one another, but clients detect inconsistencies, help correct replicas converge on a single total ordering of requests, and only rely on responses that are consistent with this total order. This approach allows Zyzzyva to reduce replication overheads to near their theoretical minima and to achieve throughputs of tens of thousands of requests per second, making BFT replication practical for a broad range of demanding services.
Using topic shifts in content-oriented XML retrieval
Authors: Ashoori Elham 
Published: October 2012

Content-oriented XML retrieval systems support access to XML repositories by retrieving, in response to user queries, XML document components (XML elements) instead of whole documents. The retrieved XML elements should not only contain information relevant to the query, but also should be specific to the given query (i.e. do not discuss other irrelevant topics).
To score XML elements according to how relevant and specific they are given a query, the content and logical structure of XML documents have been widely used. This thesis aims to examine a new source of evidence deriving from the semantic decomposition of XML documents. We consider that XML documents can be semantically decomposed through the application of a topic segmentation algorithm. Using the semantic decomposition and the logical structure of XML documents, we define the notion of topic shifts in an XML element. We then formalise the number of topic shifts to reflect the element's relevance, and more particularly its specificness, to the given user's query.

This thesis investigates the use of topic shifts in content-oriented XML retrieval, which is mainly involved in retrieving information from semi-structured (XML) documents. First, we examine the characteristics of XML elements reflected by their number of topic shifts. Second, we use the number of topic shifts to estimate the relevance of the elements in the collection. Finally, we use topic shifts to provide a
focused access
to XML documents, which aims to determine not only relevant elements, but those at the right level of granularity.

The main contributions of this thesis are the introduction of topic shifts in the context of content-oriented XML retrieval and the extensive evaluation of the ways this evidence can be employed in retrieving XML elements. This thesis demonstrates that topic shifts in XML elements constitute a useful source of evidence for both improving the ranking of XML elements, and determining elements at the right level of granularity in content-oriented XML retrieval.
The thesis is available online at http://elham.ashoori.org/publications/phd-thesis.pdf.
Content and structure summarisation for accessing XML documents
Authors: Szlávik Zoltán 
Published: October 2012

As the availability of structured documents is constantly increasing, retrieval systems able to return document portions are being developed. Structured documents, usually formatted in XML, may consist of large numbers of document portions, often organised into a hierarchical logical structure. With the high number of document portions, it is necessary to direct the attention of users of retrieval systems towards the most important document portions, and also, to give overviews of the structure of documents, in other words, to show document portions in context. This thesis investigates summarisation as a means to help searchers of XML retrieval systems in the process of accessing the contents of document portions. Two types of summarisation are investigated.
First, summaries of the textual contents of document portions, called XML elements, are studied in a user-based environment. Traditionally, summarisation is associated with whole documents or document sets, but rarely with document portions. As summaries of documents have been proved to be useful in whole document retrieval, it is considered worthwhile to investigate summaries of document portions in XML element retrieval. Summaries of elements are presented to searchers in the context of other elements from the document. The textual summaries of elements also reflect the searchers' information needs: they are query based.
The second type of summarisation investigated in this thesis is called structure summarisation. The automatic generation of tables of contents, as structure summaries, is described and examined. ToC generation is studied either when searchers' queries are available (query based structure summarisation) or otherwise (query independent structure summarisation).
The work presented in this thesis has made several contributions to the fields of summarisation and interactive XML retrieval.
The thesis is available online at http://www.dcs.qmul.ac.uk/~zolley/thesis.html.
Contracts for first-class modules
Authors: Strickland T. Stephen , Felleisen Matthias 
Published: October 2012

Behavioral software contracts express properties concerning the flow of values across component (modules, classes, etc) interfaces. These properties are often beyond the reach of theorem provers and are therefore monitored at run-time. When the monitor discovers a contract violation, it raises an exception that simultaneously pinpoints the contract violator and explains the nature of the violation.
Currently contract monitoring assumes static module interfaces. Specifically, the contract compiler partitions a contract into disjoint obligations for the static modules that communicate to an interface. At run-time, the information is used for catching and explaining contract violations. While static modules suffice for many situations, first-class modules - such as the units provided by PLT Scheme - support the dynamic and multiple linking that is often required in open software systems. The problem is, of course, that in such a world, it becomes impossible to tell from the source program alone which components have agreed to which contracts.
In this paper, we develop the semantic framework of monitoring contracts for dynamic modules. We establish the internal consistency of the semantics, and we sketch an implementation based on our experience of equipping PLT Scheme with such contracts.
Hosting an object heap on manycore hardware
Authors: Ungar David , Adams Sam S. 
Published: October 2012

In order to construct a test-bed for investigating new programming paradigms for future "manycore" systems (i.e. those with at least a thousand cores), we are building a Smalltalk virtual machine that attempts to efficiently use a collection of 56-on-chip caches of 64KB each to host a multi-megabyte object heap. In addition to the cost of inter-core communication, two hardware characteristics influenced our design: the absence of hardware-provided cache-coherence, and the inability to move a single object from one core's cache to another's without changing its address. Our design relies on an object table, and the exploitation of a user-managed caching regime for read-mostly objects. At almost every stage of our process, we obtained measurements in order to guide the evolution of our system.
The architecture and performance characteristics of a manycore platform confound old intuitions by deviating from both traditional multicore systems and from distributed systems. The implementor confronts a wide variety of design choices, such as when to share address space, when to share memory as opposed to sending a message, and how to eke out the most performance from a memory system that is far more tightly integrated than a distributed system yet far less centralized than in a several-core system. Our system is far from complete, let alone optimal, but our experiences have helped us develop new intuitions needed to rise to the manycore software challenge.
A specimen of parallel programming
Authors: Rolfe Timothy J. 
Published: October 2012

One common example of parallel processing is the implementation of the merge sort within a parallel processing environment. In the fully parallel model, you repeatedly split the sublists down to the point where you have single-element lists [3]. You then merge these in parallel back up the processing tree until you obtain the fully merged list at the top of the tree. While of theoretical interest, you probably don't have the massively parallel processor that this would require.
Instead, you can use a mixed strategy. Determine the number of parallel processes you can realistically obtain within your computing environment. Then construct the processing tree so that you have that number of leaf nodes. Within the leaf nodes of the processing tree, simply use the best sequential algorithm to accomplish the sorting, and send that result upstream to the internal nodes of the processing tree, which will merge the sorted sublists and then send the resulting list farther upstream in the tree. Figure One shows the processing tree for the case in which you have a list of 2000 items to be sorted and have resources only sufficient for four parallel processes. The processes receiving the size 500 lists use some sequential sorting algorithm. Because of the implementation environment, it will be something in the C/C++ language---either qsort() or your favorite implementation of a fast sorting algorithm.
Each leaf node (with a size 500 list) then provides the sorted result to the parent process within the processing tree. That process combines the two lists to generate a size 1000 list, and then sends that result upstream to its parent process. Finally, the root process in the processing tree merges the two lists to obtain a size 2000 list, fully sorted.
If your environment supports more parallel processes, you might take the processing tree to four levels, so that eight processes do the sequential sorting of size 250 lists. For that matter, you could even deal with circumstances in which the supported number of parallel processes is not an exact power of two. That just means that some of the leaf nodes will be at the bottommost level and some conceptually at a higher level above in the processing tree. Since in parallel processing, the time required is the time required by the slowest process, you will probably want to stick with circumstances where the number of leaf nodes is a power of two---in other words, the processing tree is a full binary tree and all leaf nodes are doing approximately the same amount of work.
RCDC
Authors: Devietti Joseph , Nelson Jacob , Bergan Tom , Ceze Luis , Grossman Dan 
Published: October 2012

Providing deterministic execution significantly simplifies the debugging, testing, replication, and deployment of multithreaded programs. Recent work has developed deterministic multiprocessor architectures as well as compiler and runtime systems that enforce determinism in current hardware. Such work has incidentally imposed strong memory-ordering properties. Historically, memory ordering has been relaxed in favor of higher performance in shared memory multiprocessors and, interestingly, determinism exacerbates the cost of strong memory ordering. Consequently, we argue that relaxed memory ordering is vital to achieving faster deterministic execution.
This paper introduces RCDC, a deterministic multiprocessor architecture that takes advantage of relaxed memory orderings to provide high-performance deterministic execution with low hardware complexity. RCDC has two key innovations: a hybrid HW/SW approach to enforcing determinism; and a new deterministic execution strategy that leverages data-race-free-based memory models (e.g., the models for Java and C++) to improve performance and scalability without sacrificing determinism, even in the presence of races. In our hybrid HW/SW approach, the only hardware mechanisms required are software-controlled store buffering and support for precise instruction counting; we do not require speculation. A runtime system uses these mechanisms to enforce determinism for arbitrary programs.
We evaluate RCDC using PARSEC benchmarks and show that relaxing memory ordering leads to performance and scalability close to nondeterministic execution without requiring any form of speculation. We also compare our new execution strategy to one based on TSO (total-store-ordering) and show that some applications benefit significantly from the extra relaxation. We also evaluate a software-only implementation of our new deterministic execution strategy.
Specifying and checking semantic atomicity for multithreaded programs
Authors: Burnim Jacob , Necula George , Sen Koushik 
Published: October 2012

In practice, it is quite difficult to write correct multithreaded programs due to the potential for unintended and nondeterministic interference between parallel threads. A fundamental correctness property for such programs is atomicity---a block of code in a program is atomic if, for any parallel execution of the program, there is an execution with the same overall program behavior in which the block is executed serially.
We propose semantic atomicity, a generalization of atomicity with respect to a programmer-defined notion of equivalent behavior. We propose an assertion framework in which a programmer can use bridge predicates to specify noninterference properties at the level of abstraction of their application. Further, we propose a novel algorithm for systematically testing atomicity specifications on parallel executions with a bounded number of interruptions---i.e. atomic blocks whose execution is interleaved with that of other threads. We further propose a set of sound heuristics and optional user annotations that increase the efficiency of checking atomicity specifications in the common case where the specifications hold.
We have implemented our assertion framework for specifying and checking semantic atomicity for parallel Java programs, and we have written semantic atomicity specifications for a number of benchmarks. We found that using bridge predicates allowed us to specify the natural and intended atomic behavior of a wider range of programs than did previous approaches. Further, in checking our specifications, we found several previously unknown bugs, including in the widely-used java.util.concurrent library.
Mnemosyne
Authors: Volos Haris , Tack Andres Jaan , Swift Michael M. 
Published: October 2012

New storage-class memory (SCM) technologies, such as phase-change memory, STT-RAM, and memristors, promise user-level access to non-volatile storage through regular memory instructions. These memory devices enable fast user-mode access to persistence, allowing regular in-memory data structures to survive system crashes.
In this paper, we present Mnemosyne, a simple interface for programming with persistent memory. Mnemosyne addresses two challenges: how to create and manage such memory, and how to ensure consistency in the presence of failures. Without additional mechanisms, a system failure may leave data structures in SCM in an invalid state, crashing the program the next time it starts.
In Mnemosyne, programmers declare global persistent data with the keyword "pstatic" or allocate it dynamically. Mnemosyne provides primitives for directly modifying persistent variables and supports consistent updates through a lightweight transaction mechanism. Compared to past work on disk-based persistent memory, Mnemosyne reduces latency to storage by writing data directly to memory at the granularity of an update rather than writing memory pages back to disk through the file system. In tests emulating the performance characteristics of forthcoming SCMs, we show that Mnemosyne can persist data as fast as 3 microseconds. Furthermore, it provides a 35 percent performance increase when applied in the OpenLDAP directory server. In microbenchmark studies we find that Mnemosyne can be up to 1400% faster than alternative persistence strategies, such as Berkeley DB or Boost serialization, that are designed for disks.
NV-Heaps
Authors: Coburn Joel , Caulfield Adrian M. , Akel Ameen , Grupp Laura M. , Gupta Rajesh K. , Jhala Ranjit , Swanson Steven 
Published: October 2012

Persistent, user-defined objects present an attractive abstraction for working with non-volatile program state. However, the slow speed of persistent storage (i.e., disk) has restricted their design and limited their performance. Fast, byte-addressable, non-volatile technologies, such as phase change memory, will remove this constraint and allow programmers to build high-performance, persistent data structures in non-volatile storage that is almost as fast as DRAM. Creating these data structures requires a system that is lightweight enough to expose the performance of the underlying memories but also ensures safety in the presence of application and system failures by avoiding familiar bugs such as dangling pointers, multiple free()s, and locking errors. In addition, the system must prevent new types of hard-to-find pointer safety bugs that only arise with persistent objects. These bugs are especially dangerous since any corruption they cause will be permanent.
We have implemented a lightweight, high-performance persistent object system called NV-heaps that provides transactional semantics while preventing these errors and providing a model for persistence that is easy to use and reason about. We implement search trees, hash tables, sparse graphs, and arrays using NV-heaps, BerkeleyDB, and Stasis. Our results show that NV-heap performance scales with thread count and that data structures implemented using NV-heaps out-perform BerkeleyDB and Stasis implementations by 32x and 244x, respectively, by avoiding the operating system and minimizing other software overheads. We also quantify the cost of enforcing the safety guarantees that NV-heaps provide and measure the costs of NV-heap primitive operations.