ppxscal/embedding_network huggingface dataset:
Command-line usage in a programming exam
Authors: Tony Greening
Venue: ACM SIGCSE Bulletin (1996)

Introductory computer science education has a strong emphasis on the teaching and learning of programming skills. In establishing that a desired level of proficiency in the use of these skills has been attained, many courses implement a practical exam where students must complete a program and get it to run correctly under supervision and unaided. This exam may, as in our case, be presented as a "barrier" exam which must be passed in order to proceed to intermediate computer science enrolment. The importance of such an event is not always matched by our understanding (as educators) of student behaviour under such conditions. The binary (pass/fail) nature of the exam tends to be reflected in student perceptions of the exam, often polarised as being "quite easy" by those who pass or "too difficult" by those who fail. This paper describes an exploration into command-line behaviour during the exam, in an attempt to gain some insight into student behavioural reaction to it. In so doing, the issue is raised as to whether or not certain actions are more likely to serve as indicators of a successful candidate, and what meaning this has for teachers and students.
Modularity and information content classes in principle-based parsing
Authors: Paola Merlo
Venue: Computational Linguistics (1995)

In recent years models of parsing that are isomorphic to a principle-based theory of grammar (most notably Government and Binding (GB) Theory) have been proposed (Berwick et al. 1991). These models are natural and direct implementations of the grammar, but they are not efficient, because GB is not a computationally modular theory. This paper investigates one problem related to the tension between building linguistically based parsers and building efficient ones. In particular, the issue of what is a linguistically motivated way of deriving a parser from principle-based theories of grammar is explored. It is argued that an efficient and faithful parser can be built by taking advantage of the way in which principles are stated. To support this claim, two features of an implemented parser are discussed. First, configurations and lexical information are precompiled separately into two tables (an X; table and a table of lexical co-occurrence) which gives rise to more compact data structures. Secondly, precomputation of syntactic features (&theta;-roles, case, etc.) results in efficient computation of chains, because it reduces several problems of chain formation to a local computation, thus avoiding extensive search of the tree for an antecedent or extensive backtracking. It is also shown that this method of building long-distance dependencies can be computed incrementally.
On Convex Subsets in Tournaments
Authors: David J. Haglin, Marty J. Wolf
Venue: SIAM Journal on Discrete Mathematics (1996)

A tournament is a complete directed graph. A convex subset is a vertex subset with the property that every two-path beginning and ending inside the convex subset is contained completely within the subset. This paper shows that every nontrivial convex subset is the closure of a subset of vertices of cardinality two. This result leads to algorithms that find all convex subsets in a tournament in $O(n^4)$ serial time and in $O(\log ^2 n)$ parallel time using $O(n^4)$ processors. Several variations of the problem that are solvable with this new algorithm are also presented.
Static detection of security flaws in object-oriented databases
Authors: Keishi Tajima
Venue: ACM SIGMOD Record (1996)

Access control in function granularity is one of the features of many object-oriented databases. In those systems, the users are granted rights to invoke composed functions instead of rights to invoke primitive operations. Although primitive operations are invoked inside composed functions, the users can invoke them only through the granted functions. This achieves access control in abstract operation level. Access control utilizing encapsulated functions, however, easily causes many "security flaws" through which malicious users can bypass the encapsulation and can abuse the primitive operations inside the functions. In this paper, we develop a technique to statically detect such security flaws. First, we design a framework to describe security requirements that should be satisfied. Then, we develop an algorithm that syntactically analyzes program code of the functions and determines whether given security requirements are satisfied or not. This algorithm is sound, that is, whenever there is a security flaw, it detects it.
Probabilistic adaptive direct optimism control in Time Warp
Authors: Alois Ferscha
Venue: Proceedings of the ninth workshop on Parallel and distributed simulation (1995)

In a distributed memory environment the communication overhead of Time Warp as induced by the rollback procedure due to &ldquo;overoptimistic&rdquo; progression of the simulation is the dominating performance factor. To limit optimism to an extent that can be justified from the inherent model parallelism, an optimism control mechanism is proposed, which by maintaining a history record of virtual time differences from the time stamps carried by arriving messages, and forecasting the timestamps of forthcoming messages, probabilistically delays the execution of scheduled events to avoid potential rollback and associated communication overhead (antimessages). After investigating statistical forecast methods which express only the central tendency of the arrival process, we demonstrate that arrival processes in the context of Time Warp simulations of timed Petri nets have certain predictable and consistent ARIMA characteristics, which encourage the use of sophisticated and recursive forecast procedures based on those models. Adaptiveness is achieved in two respects: the synchronization behavior of logical processes automatically progressing and conservatively blocking, that is the most adequate for (i) the specific simulation model and (ii) the communication/computation speed characteristics of the underlying execution platform.
The joint theater level simulation in military operations other than war
Authors: Robert H. Bolling
Venue: Proceedings of the 27th conference on Winter simulation (1995)

The Joint Theater Level Simulation (JTLS) is a hex based simulation modeling joint and combined forces. Its focus is the theater level of operations. Ground units are typically battalion or brigade sized units while individual aircraft and skips are modeled. JTLS was originally designed as a conflict model for course of action analysis work. Over the past few years it has undergone numerous, significant enhancements. The paper introduces JTLS' current capabilities and suggests possible uses for missions associated with MOOTW including peacemaking and peace enforcement operations. These include, but are not limited to, airspace control, lines of communication (LOG) protection (land air, and, sea), noncombatant evacuation operations (NEO), blockades, and nation building.
Virtual address translation for wide-address architectures
Authors: Ing-Jye Shyu, Shiuh-Pyng Shieh
Venue: ACM SIGOPS Operating Systems Review (1995)

Operating systems employ virtual memory mechanism to provide large address space for programs. The efficiency of the virtual address translation plays an important role in determining system performance. In conventional virtual memory management systems, both the forward-mapped page table scheme and inverted page table scheme are widely used to organize the page tables that record translation data. These two schemes work well for 32-bit architectures, but not for wide address (64-bit) architectures. These two schemes either needs long translation time or incurs large memory overhead when translating wide virtual address. To cope with this problem, we propose a hybrid scheme to accelerate wide virtual address translation.
Logic decomposition during technology mapping
Authors: Eric Lehman, Yosinori Watanabe, Joel Grodstein, Heather Harkness
Venue: Proceedings of the 1995 IEEE/ACM international conference on Computer-aided design (1995)

A problem in technology mapping is that quality of the final implementation depends significantly on the initially provided circuit structure. To resolve this problem, conventional techniques iteratively but separately apply technology independent transformations and technology mapping.In this paper, we propose a procedure which performs logic decomposition and technology mapping simultaneously. We show that the procedure effectively explores all possible algebraic decompositions. It finds an optimal tree implementation over all the circuit structures examined, while the run time is typically logarithmic in the number of decompositions.
Salvage-Embeddings of Complete Trees
Authors: Sandeep N. Bhatt, Fan R. K. Chung, Frank Thomson Leighton, Arnold L. Rosenberg
Venue: SIAM Journal on Discrete Mathematics (1995)

A salvage-embedding (S-embedding) maps an $M$-leaf complete binary tree $\cal G$ into an $(N > M)$-leaf complete binary tree $\cal H$, the fraction $G$ of whose leaves have been labeled {\sc good}. The S-embedding maps leaves of $\cal G$ one-to-one to {\sc good} leaves of $\cal H$; it may be many-to-one on internal nodes. The quality of an S-embedding depends on its harvest, the ratio $H \eqdef M/GN$, and its congestion, the largest number of edges of $\cal G$ that get "routed" across the same edge of $\cal H$. We study three scenarios. In the worst-case scenario, given any target harvest $H \leq 1/2$, one can S-embed a $2^{\lfloor \log (HGN) \rfloor}$-leaf $\cal G$ in $\cal H$ with congestion $\log \log N +$ a constant depending only on $G$ and $H$, no matter how the {\sc good} leaves are distributed; this congestion cannot be lowered by more than a small constant factor. In the expected-case scenario---where leaves of $\cal H$ are labeled {\sc good} or not, independently, with fixed probability---with probability exceeding $1 - N^{- \Omega(1)}$, for any target harvest $H \leq 1/8$, one can S-embed a $2^{\lfloor HN \rfloor}$-leaf $\cal G$ in $\cal H$ with congestion $O(\log \log \log N)$. In the salvaging scenario, we present an algorithm that, in time $O(CN (\log N)^{3C+2})$, S-embeds in a given a leaf-labeled $\cal H$ the largest possible $\cal G$, subject to the prespecified bound $C$ on congestion. This work is inspired by the problem of salvaging a fault-free subnetwork of a leaf-tree machine---a tree architecture whose leaves hold "full-power" processors and whose nonleaf nodes hold "rudimentary" processors that route messages and perform simple combining tasks.
Algorithm 674: Fortran codes for estimating the one-norm of a real or complex matrix, with applications to condition estimation
Authors: Nicholas J. Higham
Venue: ACM Transactions on Mathematical Software (TOMS) (1989)

We omitted giving this article an ACM algorithm number when it was first published in its entirety in the December 1988 issue of TOMS, Vol. 14, No. 4, pp. 381&ndash;396. To correct this, we do so here, and reprint the title as a pointer to the original article.
Speeding up irregular applications in shared-memory multiprocessors: memory binding and group prefetching
Authors: Zheng Zhang, Josep Torrellas
Venue: ACM SIGARCH Computer Architecture News (1995)

While many parallel applications exhibit good spatial locality, other important codes in areas like graph problem-solving or CAD do not. Often, these irregular codes contain small records accessed via pointers. Consequently, while the former applications benefit from long cache lines, the latter prefer short lines. One good solution is to combine short lines with prefetching. In this way, each application can exploit the amount of spatial locality that it has. However, prefetching, if provided, should also work for the irregular codes. This paper presents a new prefetching scheme that, while usable by regular applications, is specifically targeted to irregular ones: Memory Binding and Group Prefetching.The idea is to hardware-bind and prefetch together groups of data that the programmer suggests are strongly related to each other. Examples are the different fields in a record or two records linked by a permanent pointer. This prefetching scheme, combined with short cache lines, results in a memory hierarchy design that can be exploited by both regular and irregular applications. Overall, it is better to use a system with short lines (16-32 bytes) and our prefetching than a system with long lines (128 bytes) with or without our prefetching. The former system runs 6 out of 7 Splash-class applications faster. In particular, some of the most irregular applications run 25-40% faster.
A recursive algorithm for binary multiplication and its implementation
Authors: Renato De Mori, Régis Cardin
Venue: ACM Transactions on Computer Systems (TOCS) (1985)

A new recursive algorithm for deriving the layout of parallel multipliers is presented. Based on this algorithm, a network for performing multiplications of two's complement numbers is proposed. The network can be implemented in a synchronous or an asynchronous way. If the factors to be multiplied have N bits, the area complexity of the network is O(N2) for practical values of N as in the case of cellular multipliers. Due to the design approach based on a recursive algorithm, a time complexity O(log N) is achieved. It is shown how the structure can he pipelined with period complexity O(1) and used for single and double precision multiplication.
Efficient Algorithms for a Class of Partitioning Problems
Authors: M. Ashraf Iqbal, Shahid H. Bokhari
Venue: IEEE Transactions on Parallel and Distributed Systems (1995)

We address the problem of optimally partitioning the modules of chain- or tree-like tasks over chain-structured or host-satellite multiple computer systems. This important class of problems includes many signal processing and industrial control applications. Prior research has resulted in a succession of faster exact and approximate algorithms for these problems. We describe polynomial exact and approximate algorithms for this class that are better than any of the previously reported algorithms. Our approach is based on a preprocessing step that condenses the given chain or tree structured task into a monotonic chain or tree. The partitioning of this monotonic task can then be carried out using fast search techniques.Index Terms¿Approximation algorithms, assignments, chains, distributed computing, host-satellite systems, load balancing, partitioning, parallel processing, trees.
Efficient support of location transparency in concurrent object-oriented programming languages
Authors: WooYoung Kim, Gul Agha
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

We describe the design of a runtime system for a fine-grained concurrent object-oriented (actor) language and its performance. The runtime system provides considerable flexibility to users; specifically, it supports location transparency, actor creation and dynamic placement, and migration. The runtime system includes an efficient distributed name server, a latency hiding scheme for remote actor creation, and a compiler-controlled intra-node scheduling mechanism for local messages and dynamic load balancing. Our preliminary evaluation results suggest that the efficiency that is lost by the greater flexibility of actors can be restored by an efficient runtime system which provides an open interface that can be used by a compiler to allow optimizations. On several standard algorithms, the performance results for our system are comparable to efficient C implementations.
When Trees Collide: An Approximation Algorithm for theGeneralized Steiner Problem on Networks
Authors: Ajit Agrawal, Philip Klein, R. Ravi
Venue: SIAM Journal on Computing (1995)

We give the first approximation algorithm for the generalized network Steiner problem, a problem in network design. An instance consists of a network with link-costs and, for each pair $\{i,j\}$ of nodes, an edge-connectivity requirement $r_{ij}$. The goal is to find a minimum-cost network using the available links and satisfying the requirements. Our algorithm outputs a solution whose cost is within $2\lceil \log_2(r+1)\rceil$ of optimal, where $r$ is the highest requirement value. In the course of proving the performance guarantee, we prove a combinatorial min-max approximate equality relating minimum-cost networks to maximum packings of certain kinds of cuts. As a consequence of the proof of this theorem, we obtain an approximation algorithm for optimally packing these cuts; we show that this algorithm has application to estimating the reliability of a probabilistic network.
A traffic for MPEG-coded VBR streams
Authors: Marwan Krunz, Herman Hughes
Venue: ACM SIGMETRICS Performance Evaluation Review (1995)

Compression of digital video is the only viable means to transport real-time full-motion video over BISDN/ATM networks. Traffic streams generated by video compressors exhibit complicated patterns which vary from one compression scheme to another. In this paper we investigate the traffic characteristics of video streams which are compressed based on the MPEG standard. Our study is based on 23 minutes of video obtained from an entertainment movie. A particular significance of our data is that it contains all types of coded frames, namely: Intra-coded (I), Prediction (P), and Bidirectional (B) MPEG frames. We describe the statistical behavior of the VBR stream using histograms and autocorrelation functions. A procedure is developed to determine the instants of a scene change based on the changes in the size of successive I frames. It is found that the length of a scene can be modeled by a geometric distribution.A model for an MPEG traffic source is developed in which frames are generated according to the compression pattern of the captured video stream. For each frame type, the number of cells per frame is fitted by a lognormal distribution whose parameters are determined by the frame type. The appropriateness and limitations of the model are examined by studying the multiplexing performance of MPEG streams. Simulations of an ATM multiplexer are conducted, in which traffic sources are derived from the measured VBR trace as well as the proposed model. The queueing performance in both cases is found to be relatively close.
A novel approach towards automatic data distribution
Authors: Jordi Garcia, Eduard Ayguadé, Jesus Lebarta
Venue: Proceedings of the 1995 ACM/IEEE conference on Supercomputing (CDROM) (1995)

Data distribution is one of the key aspects that a parallelizing compiler for a distributed memory architecture should consider, in order to get efficiency from the system. The cost of accessing local and remote data can be one or several orders of magnitude different, and this can dramatically affect performance. In this paper, we present a novel approach to automatically perform static data distribution. All the constraints related to parallelism and data movement are contained in a single data structure, the Communication-Parallelism Graph (CPG). The problem is solved using a linear 0-1 integer programming model and solver. In this paper we present the solution for one-dimensional array distributions, although its extension to multi-dimensional array distributions is also outlined. The solution is static in the sense that the layout of the arrays does not change during the execution of the program. We also show the feasibility of using this approach to solve the problem in terms of compilation time and quality of the solutions generated.
First Sight: A Human Body Outline Labeling System
Authors: Maylor K. Leung, Yee-Hong Yang
Venue: IEEE Transactions on Pattern Analysis and Machine Intelligence (1995)

First Sight, a vision system in labeling the outline of a moving human body, is proposed in this paper. The emphasis of First Sight is on the analysis of motion information gathered solely from the outline of a moving human object. Two main processes are implemented in First Sight. The first process uses a novel technique to extract the outline of a moving human body from an image sequence. The second process, which employs a new human body model, interprets the outline and produces a labeled two-dimensional human body stick figure for each frame of the image sequence. Extensive knowledge of the structure, shape, and posture of the human body is used in the model. The experimental results of applying the technique on unedited image sequences with self-occlusions and missing boundary lines are encouraging.
Data mining using two-dimensional optimized association rules: scheme, algorithms, and visualization
Authors: Takeshi Fukuda, Yasukiko Morimoto, Shinichi Morishita, Takeshi Tokuyama
Venue: ACM SIGMOD Record (1996)

We discuss data mining based on association rules for two numeric attributes and one Boolean attribute. For example, in a database of bank customers, "Age" and "Balance" are two numeric attributes, and "CardLoan" is a Boolean attribute. Taking the pair (Age, Balance) as a point in two-dimensional space, we consider an association rule of the form((Age, Balance) isin; P) rArr; (CardLoan = Yes),which implies that bank customers whose ages and balances fall in a planar region P tend to use card loan with a high probability. We consider two classes of regions, rectangles and admissible (i.e. connected and x-monotone) regions. For each class, we propose efficient algorithms for computing the regions that give optimal association rules for gain, support, and confidence, respectively. We have implemented the algorithms for admissible regions, and constructed a system for visualizing the rules.
Comparison of surface and derivative evaluation methods for the rendering of NURB surfaces
Authors: William L. Luken, Fuhua Cheng
Venue: ACM Transactions on Graphics (TOG) (1996)

Three methods for evaluating the surface coordinates, first derivatives, and normal vectors of a NURB surface are compared. These methods include forward differencing, knot insertion, and a tow-stage Cox-de Boor technique. The computational complexity of each of these techniques is analyzed and summarized. The use of Hermite functions is shown to yield a poor approximation for the shading functions of a NURB surface. An improved method for computing derivatives by knot insertion is presented. An efficient algorithm for computing the foward difference matrix and a method for using foward differencing to compute the first derivatives of a NURB surface are also presented.
Self-organization as an iterative kernel smoothing process
Authors: Filip Mulier, Vladimir Cherkassky
Venue: Neural Computation (1995)

Kohonen's self-organizing map, when described in a batch processing mode, can be interpreted as a statistical kernel smoothing problem. The batch SOM algorithm consists of two steps. First, the training data are partitioned according to the Voronoi regions of the map unit locations. Second, the units are updated by taking weighted centroids of the data falling into the Voronoi regions, with the weighing function given by the neighborhood. Then, the neighborhood width is decreased and steps 1, 2 are repeated. The second step can be interpreted as a statistical kernel smoothing problem where the neighborhood function corresponds to the kernel and neighborhood width corresponds to kernel span. To determine the new unit locations, kernel smoothing is applied to the centroids of the Voronoi regions in the topological space. This interpretation leads to some new insights concerning the role of the neighborhood and dimensionality reduction. It also strengthens the algorithm's connection with the Principal Curve algorithm. A generalized self-organizing algorithm is proposed, where the kernel smoothing step is replaced with an arbitrary nonparametric regression method.