工学博士, 東京大学

Informatics, Software

Mar. 1988
The University of Tokyo, Graduate School, Division of Engineering, 情報工学専攻

Mar. 1985
The University of Tokyo, Graduate School, Division of Engineering, 情報工学専門課程

Mar. 1983
The University of Tokyo, Faculty of Engineering, 計数工学科

Apr. 1975 - Mar. 1978
麻布高等学校

Oct. 2011 - Sep. 2023
連携会員, 日本学術会議

01 Apr. 2016 - 31 Mar. 2018
プログラミング論研究会主査, 日本ソフトウェア科学会, Society

01 Apr. 2013 - 31 Mar. 2018
プログラミング・シンポジウム 幹事長, 情報処理学会, Society

Jun. 2017
理事, 日本ソフトウェア科学会, Society

Apr. 2008 - Mar. 2012
プログラミング研究会運営委員, 情報処理学会, Society

Apr. 2005 - Mar. 2012
プログラミング研究会論文誌編集委員, 情報処理学会, Society

Apr. 2006 - Mar. 2008
プログラミング研究会論文誌編集委員長, 情報処理学会, Society

Apr. 2006 - Mar. 2007
プログラミング研究会主査, 情報処理学会, Society

Apr. 2003 - Mar. 2006
プログラミング研究会幹事, 情報処理学会, Society

Apr. 2000 - Mar. 2004
プログラミング研究会論文誌編集委員, 情報処理学会, Society

Apr. 1997 - Mar. 2000
プログラミング研究会連絡委員, 情報処理学会, Society

1993
学会誌編集委員, 日本ソフトウェア科学会, Society

11 Mar. 2018
日本ソフトウェア科学会プログラミング論研究会
オブジェクトレイアウトを表すメタオブジェクトを含むヒープに対するスレッド化コンパクション
日本ソフトウェア科学会 第23回プログラミングおよびプログラミング言語ワークショップ (PPL2021) 論文賞, 小野澤 拓;鵜川 始陽;岩崎 英哉
Japan society

07 Mar. 2018
日本ソフトウェア科学会プログラミング論研究会
Fregelコンパイラにおける不要な値送受信の削減
日本ソフトウェア科学会 第20回プログラミングおよびプログラミング言語ワークショップ (PPL2018) 論文賞, 加藤直斗;岩崎英哉
Japan society

Haskell Library for Safer Virtual Machine Introspection (Experience Report)
Takato Otsuka; Hideya Iwasaki
Proc. ACM SIGPLAN Haskell Symposium 2023 (Haskell 2023), ACM, 89-96, Sep. 2023, Peer-reviwed
International conference proceedings, English

The TABLET Programming Learning Environment: from Block-based to Text-based Programming
Takumi Miyajima; Hideya Iwasaki; Yasushi Kuno
Journal of Information Processing, 30, 729-741, Oct. 2022, Peer-reviwed
Scientific journal, English

Generating Virtual Machine Code of JavaScript Engine for Embedded Systems
Yuta Hirasawa; Hideya Iwasaki; Tomoharu Ugawa; Hiro Onozawa
Journal of Information Processing, 30, 679-693, Oct. 2022, Peer-reviwed
Scientific journal, English

Replication-based Object Persistence by Reachability
Kotaro Matsumoto; Tomoharu Ugawa; Hideya Iwasaki
Proc. 2022 ACM SIGPLAN International Symposium on Memory Management (ISMM 2022), 43-56, Jun. 2022, Peer-reviwed
International conference proceedings, English

Fregel: a functional domain-specific language for vertex-centric large-scale graph processing
Hideya Iwasaki; Kento Emoto; Akimasa Morihata; Kiminori Matsuzaki; Zhenjiang Hu
Journal of Functional Programming, Cambridge University Press (CUP), 32, e4:1-e4:69, Jan. 2022, Peer-reviwed,
The vertex-centric programming model is now widely used for processing large graphs. User-defined vertex programs are executed in parallel over every vertex of a graph, but the imperative and explicit message-passing style of existing systems makes defining a vertex program unintuitive and difficult. This article presents Fregel, a purely functional domain-specific language for processing large graphs and describes its model, design, and implementation. Fregel is a subset of Haskell, so Haskell tools can be used to test and debug Fregel programs. The vertex-centric computation is abstracted using compositional programming that uses second-order functions on graphs provided by Fregel. A Fregel program can be compiled into imperative programs for use in the Giraph and Pregel+ vertex-centric frameworks. Fregel’s functional nature without side effects enables various transformations and optimizations during the compilation process. Thus, the programmer is freed from the burden of program optimization, which is manually done for existing imperative systems. Experimental results for typical examples demonstrated that the compiled code can be executed with reasonable and promising performance.
Scientific journal

アプリケーションと実行環境に適応したカスタマイズが可能なJavaScript処理系
Hideya Iwasaki
コンピュータソフトウェア, 38, 3, 23-40, Aug. 2021, Peer-reviwed
Scientific journal, Japanese

Fusuma: Double-Ended Threaded Compaction
Hiro Onozawa; Tomoharu Ugawa; Hideya Iwasaki
Proc. 2021 ACM SIGPLAN International Symposium on Memory Management (ISMM 2021), 94-106, Jun. 2021, Peer-reviwed
International conference proceedings, English

Region-based Detection of Essential Differences in Image-based Visual Regression Testing
Haruto Tanno; Yu Adachi; Yu Yoshimura; Katsuyuki Natsukawa; Hideya Iwasaki
Journal of Information Processing, 情報処理学会, 28, 268-278, Apr. 2020, Peer-reviwed
Scientific journal, English

Fregel コンパイラにおける不要な値送受信の削減
加藤直斗; 岩崎英哉
コンピュータソフトウェア, 36, 2, 28-46, May 2019, Peer-reviwed
Scientific journal, Japanese

dajFS: A New File System with Per-Directory Adaptive Journaling
Wataru Aoyama; Hideya Iwasaki
Journal of Information Processing, 27, 369-377, May 2019, Peer-reviwed
Scientific journal, English

Suspend-less Debugging for Interactive and/or Realtime Programs
Haruto Tanno; Hideya Iwasaki
Proc. 12th IEEE International Conference on Software Testing, Verification and Validation (ICST 2019), 194-205, Apr. 2019, Peer-reviwed
International conference proceedings, English

eJSTK: Building JavaScript Virtual Machines with Customized Datatypes
Tomoharu Ugawa; Hideya Iwasaki; Takafumi Kataoka
Journal of Computer Languages, 51, 261-279, Apr. 2019, Peer-reviwed
Scientific journal, English

Optimizing Declarative Parallel Distributed Graph Processing by Using Constraint Solvers
Akimasa Morihata; Kento Emoto; Kiminori Matsuzaki; Zhenjiang Hu; Hideya Iwasaki
Proc. 14th International Symposium on Functional and Logic Programming (FLOPS 2018), Lecture Notes in Computer Science 10818, 166-181, May 2018, Peer-reviwed
International conference proceedings, English

A Framework for Constructing JavaScript Virtual Machines with Customized Datatype Representations
Takafumi Kataoka; Tomoharu Ugawa; Hideya Iwasaki
Proc. 33rd ACM/SIGAPP Symposium on Applied Computing (SAC 2018), 1238-1247, Apr. 2018, Peer-reviwed
International conference proceedings, English

A Debugger-Cooperative Higher-Order Contract System in Python
Ryoya Arai; Shigeyuki Sato; Hideya Iwasaki
Proc. 14th Asian Symposium on Programming Languages and Systems (APLAS 2016), Lecture Notes in Computer Science 10017, Springer Verlag, 148-168, Nov. 2016, Peer-reviwed, Contract programming is one of the most promising ways of enhancing the reliability of Python, which becomes increasingly desired. Higher-order contract systems that support fully specifying the behaviors of iterators and functions are desirable for Python but have not been presented yet. Besides, even with them, debugging with contracts in Python would still be burdensome because of delayed contract checking. To resolve this problem, we present PyBlame, a higher-order contract system in Python, and ccdb, a source-level debugger equipped with features dedicated to debugging with delayed contract checking. PyBlame and ccdb are designed on the basis of the standard of Python and thus friendly to many Python programmers. We have experimentally confirmed the advantage and the efficacy of PyBlame and ccdb through the web framework Bottle.
International conference proceedings, English

Think Like a Vertex, Behave Like a Function! A Functional DSL for Vertex-Centric Big Graph Processing
Kento Emoto; Kiminori Matsuzaki; Zhenjiang Hu; Akimasa Morihata; Hideya Iwasaki
Proc. 21st ACM SIGPLAN International Conference on Functional Programming (ICFP 2016), ASSOC COMPUTING MACHINERY, 200-213, Sep. 2016, Peer-reviwed, The vertex-centric programming model, known as "think like a vertex", is being used more and more to support various big graph processing methods through iterative super steps that execute in parallel a user-defined vertex program over each vertex of a graph. However, the imperative and message-passing style of existing systems makes defining a vertex program unintuitive. In this paper, we show that one can benefit more from "Thinking like a vertex" by "Behaving like a function" rather than "Acting like a procedure" with full use of side effects and explicit control of message passing, state, and termination. We propose a functional approach to vertex-centric graph processing in which the computation at every vertex is abstracted as a higher-order function and present Fregel, a new domain-specific language. Fregel has clear functional semantics, supports declarative description of vertex computation, and can be automatically translated into Pregel, an emerging imperative-style distributed graph processing framework, and thereby achieve promising performance. Experimental results for several typical examples show the promise of this functional approach.
International conference proceedings, English

Improving Floating-Point Numbers: A Lazy Approach to Adaptive Accuracy Refinement for Numerical Computations
Hideyuki Kawabata; Hideya Iwasaki
Proc. 25th European Symposium on Programming (ESOP 2016), Lecture Notes in Computer Science 9632, SPRINGER-VERLAG BERLIN, 390-418, Apr. 2016, Peer-reviwed, Numerical computation using floating-point numbers is prone to accuracy degradation due to round-off errors and cancellation of significant digits. Although multiple-precision arithmetic might alleviate this problem, it is difficult to statically decide the optimal degree of precision for each operation in a program. This paper presents a solution to this problem: the partial results in floating-point representations are incrementally improved using adaptive control. This process of adaptive accuracy refinement is implemented using lazy lists, each one containing a sequence of floating-point numbers with gradually improving accuracies. The computation process is driven by the propagation of demand for more accurate results. The concept of this improving floating-point number (IFN) mechanism was experimentally implemented in two ways: as a Haskell library and as a pure C library. Despite the simple approach, the results for numerical problems demonstrated the effectiveness of this mechanism.
International conference proceedings, English

Integrating Lua into C for embedding Lua interpreters in a C application
Akira Tanimura; Hideya Iwasaki
Proc. 31st ACM/SIGAPP Symposium on Applied Computing (SAC 2016), Association for Computing Machinery, 1936-1943, Apr. 2016, Peer-reviwed, Most scripting languages provide a C API that enables them to cooperate with programs written in C. The scripting language Lua is designed to be embedded in other host languages. However, when embedding Lua interpreters in a C program, the programmer must use complicated C API functions to write glue code between C and Lua. Obeying the protocols of Lua's C API not only increases the development cost but also makes the program error prone. We propose LuCa, a domain specific language for developing integrated applications of Lua and C, with C as the host language. LuCa enables the programmer to write glue code in a combination of Lua and C with some syntactic extensions. By using LuCa, the programmer need not use C API functions
the programmer can directly write Lua-like code, which is much clearer than C code that uses many API calls. We have implemented a LuCa processor as a translator from LuCa code into C code that calls appropriate C API functions. The translated code can be compiled by a standard C compiler and executed by linking a standard Lua interpreter.
International conference proceedings, English

Efficient Use of Hardware Transactional Memory for Parallel Mesh Generation
Tetsu Kobayashi; Shigeyuki Sato; Hideya Iwasaki
Proc. 44th International Conference on Parallel Processing (ICPP 2015), IEEE, 600-609, Sep. 2015, Peer-reviwed, Efficient transactional executions are desirable for parallel implementations of algorithms with graph refinements. Hardware transactional memory (HTM) is promising for easy yet efficient transactional executions. Long HTM transactions, however, abort with high probability because of hardware limitations. Unfortunately, Delaunay mesh refinement (DMR), which is an algorithm with graph refinements for mesh generation, causes long transactions. Its parallel implementation naively based on HTM therefore leads to poor performance. To utilize HTM efficiently for parallel implementation of DMR, we present an approach to shortening transactions. Our HTM-based implementations of DMR achieved significantly higher throughput and better scalability than a naive HTM-based one and lock-based ones. On a quad-core Haswell processor, the absolute speedup of one of our implementations was up to 2.64 with 16 threads.
International conference proceedings, English

Thunk Recycling for Lazy Functional Languages: Operational Semantics and Correctness
Yasunao Takano; Hideya Iwasaki
Proc. 30th ACM/SIGAPP Symposium on Applied Computing (SAC 2015), ASSOC COMPUTING MACHINERY, 2079-2086, Apr. 2015, Peer-reviwed, Lazy evaluation helps programmers write clear programs. However, it has significant run-time overheads for building many as-yet unevaluated expressions, or thunks. Because thunk allocation is a space-consuming task, it is important to reduce the number of thunks in order to improve the performance of a lazy functional program. To resolve this problem, a mechanism named thunk recycling have been proposed. Thunk recycling suppresses thunk generation by reusing and updating an already allocated thunk at the tail of a list, on the condition that the thunk is singly referred. The preliminary implementation of thunk recycling has been developed in Glasgow Haskell Compiler and has succeeded in reducing total memory allocations for benchmark programs. This paper addresses the formal issue of thunk recycling. We present a small-step operational semantics of the thunk recycling and show the correctness of this mechanism on the basis of bisimulation.
International conference proceedings, English

Glasgow Haskell Compiler 上の遅延オブジェクト再利用手法の設計と実装
高野保真; 岩崎英哉; 佐藤重幸
コンピュータソフトウェア, 32, 1, 253-287, Jan. 2015, Peer-reviwed
Scientific journal, Japanese

LibDSL: A Library for Developing Embedded Domain Specific Languages in D via Template Metaprogramming
Masato Shioda; Hideya Iwasaki; Shigeyuki Sato
Proc. 13th International Conference on Generative Programming: Concepts and Experiences (GPCE 2014), ASSOC COMPUTING MACHINERY, 63-72, Sep. 2014, Peer-reviwed, This paper presents a library called LibDSL that helps the implementer of an embedded domain specific language (EDSL) effectively develop it in D language. The LibDSL library accepts as input some kinds of "specifications" of the EDSL that the implementer is going to develop and a D program within which an EDSL source program written by the user is embedded. It produces the front-end code of an LALR parser for the EDSL program and back-end code of the execution engine. LibDSL is able to produce two kinds of execution engines, namely compiler-based and interpreter-based engines, either of which the user can properly choose depending on whether an EDSL program is known at compile time or not. We have implemented the LibDSL system by using template metaprogramming and other advanced facilities such as compile-time function execution of D language. EDSL programs developed by means of LibDSL have a nice integrativeness with the host language.
International conference proceedings, English

XQuery Streaming by Forest Transducers
Shizuya Hakuta; Sebastian Maneth; Keisuke Nakano; Hideya Iwasaki
Proc. 30th IEEE International Conference on Data Engineering (ICDE 2014), IEEE, 952-963, Apr. 2014, Peer-reviwed, Streaming of XML transformations is a challenging task and only a few existing systems support streaming. Research approaches generally define custom fragments of XQuery and XPath that are amenable to streaming, and then design custom algorithms for each fragment. These languages have several shortcomings. Here we take a more principled approach to the problem of streaming XQuery-based transformations. We start with an elegant transducer model for which many static analysis problems are well-understood: the Macro Forest Transducer (MFT). We show that a large fragment of XQuery can be translated into MFTs - indeed, a fragment of XQuery, that can express important features that are missing from other XQuery stream engines, such as GCX: our fragment of XQuery supports XPath predicates and let-statements. We then use an existing streaming engine for MFTs and apply a well-founded set of optimizations from functional programming such as strictness analysis and deforestation. Our prototype achieves time and memory efficiency comparable to the fastest known engine for XQuery streaming, GCX. This is surprising because our engine relies on the OCaml built in garbage collector and does not use any specialized buffer management, while GCX's efficiency is due to clever and explicit buffer management.
International conference proceedings, English

Adaptive Scanning Reduces Sweep Time for the Lisp2 Mark-Compact Garbage Collector
Kazuya Morikawa; Tomoharu Ugawa; Hideya Iwasaki
Proc. 2013 International Symposium on Memory Management (ISMM 2013), ASSOC COMPUTING MACHINERY, 15-26, Jun. 2013, Peer-reviwed, Mark-compact garbage collection helps long-running programs avoid fragmentation. The Lisp2 mark-compact collector is a classic but still widely-used compaction algorithm. It sequentially scans the entire heap to compact all live objects at one end of the heap while preserving their order of addresses. Since the heap is generally large, this scanning takes a long time. Although some collectors adopt a separate bitmap into which mark bits of objects are stored to reduce the scanning time, we observed that scanning the bitmap can take longer than scanning the heap if objects are densely located. We propose a new scanning method from this observation, which adaptively alternates methods of scanning depending on heap usage; it scans those parts of the heap where live objects are densely located whereas it scans the bitmap for the remaining parts. We implemented this scanning method in the Lisp2 collector of Jikes RVM. The experimental results revealed that the adaptive scanner scanned faster than the method that only scanned the heap and the method that only scanned the bitmap.
International conference proceedings, English

Pruning with Improving Sequences in Lazy Functional Programs
Hideya Iwasaki; Takeshi Morimoto; Yasunao Takano
Higher-Order and Symbolic Computation, 24, 4, 281-309, Aug. 2012, Peer-reviwed, This paper presents a library based on improving sequences and demonstrates that they are effective for pruning unnecessary computations while retaining program clarity. An improving sequence is a monotonic sequence of approximation values of a final value that are improved gradually according to some ordering relation. A computation using improving sequences proceeds by demanding for the next approximation value. If an approximation value in the middle of the improving sequence has sufficient information to yield the result of some part of the program, the computations that produce the remaining values can be pruned. By combining suitable improving sequences and primitive functions defined for the sequences, we can write efficient programs in the same form as simple and naive programs. We give examples that show the effectiveness of improving sequences and show by program calculation that a simple minimax-like program using improving sequences implements a well-known branch-and-bound searching algorithm. © Springer Science+Business Media, LLC 2012.
Scientific journal, English

Improvements of Recovery from Marking Stack Overflow in Mark Sweep Garbage Collection
Tomoharu Ugawa; Hideya Iwasaki; Taiichi Yuasa
情報処理学会論文誌 プログラミング, 5, 1, 1-8, Mar. 2012, Peer-reviwed, Mark sweep garbage collection (GC) is usually implemented using a mark stack for a depth first search that marks all objects reachable from the root set. However, the required size of the mark stack depends on the application, and its upper bound is proportional to the size of the heap. It is not acceptable in most systems to reserve memory for such a large mark stack. To avoid unacceptable memory overhead, some systems limit the size of the mark stack. If the mark stack overflows, the system scans the entire heap to find objects that could not be pushed due to overflow and traverses their children. Since the scanning takes a long time, this technique is inefficient for applications that are likely to cause overflows. In this research, we propose a technique to record rough locations of objects that failed to be pushed so that they can be found without scanning the entire heap. We use a technique similar to the card table of mostly concurrent GC to record rough locations. © 2012 Information Processing Society of Japan.
Scientific journal, English

Glasgow Haskell Compiler における再帰的データ構造のための遅延オブジェクトの再利用
高野保真; 岩崎英哉; 鵜川始陽
情報処理学会論文誌 プログラミング, 情報処理学会, 5, 2, 67-78, Mar. 2012, Peer-reviwed, 遅延評価は，プログラムの簡潔な記述を可能にするため，純関数型言語などで採用されている．特にリストなどの再帰的データ構造を扱う際には，必要に応じて評価を進めることが可能となり，遅延評価により得られる記述性の向上は大きい．一方，計算を遅延するために必要なオブジェクト（遅延オブジェクト）の生成は，プログラム実行時のオーバヘッドとなってしまうため，効率の良い遅延評価機構を実装するには，遅延オブジェクトの削減が必要である．本論文は，リストのような線形に再帰的に定義される代数データ構造に注目し，必要となる遅延オブジェクトを再利用する手法を提案する．提案手法は，すでに割り当てられている遅延オブジェクトの保持している値を更新して再利用する．このような再利用を可能とするために，提案手法は，コンパイル時にプログラム変換を行い，再利用対象とする遅延オブジェクトへの参照を単一にする．提案手法を，純関数型言語Haskellの処理系であるGlasgow Haskell Compiler上に実装し，実験を行った．その結果，オーバヘッドはあるものの，総メモリ割当て量を削減できることが分かった．Lazy evaluation helps programmers write clear programs. However, it has significant run-time overheads for building many as-yet unevaluated expressions, or thunks. Because thunk allocation is a space-consuming task, it is important to reduce the number of thunks in order to improve the performance of a lazy functional program. We propose static analysis algorithms that achieve the thunk reuse technique. Thunk generation is suppressed by reusing an already allocated thunk at the tail of a list, on the condition that the thunk is singly referred, i.e., pointed to only from the tail field of a cons cell. This method guarantees that reused thunks definitely satisfy this singly referred condition on the basis of a static analysis with program transformations. We have implemented our method in the Glasgow Haskell Compiler and measured total memory allocations and execution times for some programs.
Scientific journal, Japanese

SAW: Java Synchronization Selection from Lock or Software Transactional Memory
Yuji Yamada; Hideya Iwasaki; Tomoharu Ugawa
Proc. 17th IEEE International Conference on Parallel and Distributed Systems (ICPADS 2011), IEEE, 104-111, Dec. 2011, Peer-reviwed, To rewrite a sequential program into a concurrent one, the programmer has to enforce atomic execution of a sequence of accesses to shared memory to avoid unexpected inconsistency. There are two means of enforcing this atomicity: one is the use of lock-based synchronization and the other is the use of software transactional memory (STM). However, it is difficult to predict which one is more suitable for an application than the other without trying both mechanisms because their performance heavily depends on the application. We have developed a system named SAW that decouples the synchronization mechanism from the application logic of a Java program and enables the programmer to statically select a suitable synchronization mechanism from a lock or an STM. We introduce annotations to specify critical sections and shared objects. In accordance with the annotated source program and the programmer's choice of a synchronization mechanism, SAW generates aspects representing the synchronization processing. By comparing the rewriting cost using SAW and that using individual synchronization mechanism directly, we show that SAW relieves the programmer's burden. Through several benchmarks, we demonstrate that SAW is an effective way of switching synchronization mechanisms according to the characteristics of each application.
International conference proceedings, English

Automatic Parallelization via Matrix Multiplication
Shigeyuki Sato; Hideya Iwasaki
Proc. 32nd ACM SIGPLAN Conference on Programming Language Design and Implementation (PLDI 2011), ASSOC COMPUTING MACHINERY, 470-479, Jun. 2011, Peer-reviwed, Existing work that deals with parallelization of complicated reductions and scans focuses only on formalism and hardly dealt with implementation. To bridge the gap between formalism and implementation, we have integrated parallelization via matrix multiplication into compiler construction. Our framework can deal with complicated loops that existing techniques in compilers cannot parallelize. Moreover, we have sophisticated our framework by developing two sets of techniques. One enhances its capability for parallelization by extracting max-operators automatically, and the other improves the performance of parallelized programs by eliminating redundancy. We have also implemented our framework and techniques as a parallelizer in a compiler. Experiments on examples that existing compilers cannot parallelize have demonstrated the scalability of programs parallelized by our implementation.
International conference proceedings, English

Starvation-free Heap Size for Replication-Based Incremental Compacting Garbage Collection
Tomoharu Ugawa; Hideya Iwasaki; Taiichi Yuasa
Proc. International Lisp Conference (ILC 2010), 43-50, Oct. 2010, Peer-reviwed, We present a method to estimate the amount of the heap required to execute application programs on runtime systems with our replication-based incremental compacting garbage collector. Our method provides a strategy for adjusting the timing to trigger garbage collection and choosing a heap region to be evacuated during partial compaction, which moves all objects in one part of the heap to the rest of the heap. The method is also used to determine the minimum heap size that guarantees free memory never exhausts during incremental garbage collection. Furthermore, we ensure that allocation never fails due to fragmentation with the strategy. The strategy is to reserve a contiguous free area and to prohibit the allocator from allocating in that area until garbage collection is triggered. When it becomes necessary to use the reserved free area to satisfy an allocation request, we trigger garbage collection. We show that, with this strategy, an application never fails to allocate objects with a larger heap than R + 2√2Ra + 3a plus space overhead caused by the heap layout, where R is the maximum amount of live objects and a is the upper bound of the possible amount of allocation during a single collection cycle. © 2010 ACM.
International conference proceedings, English

サーバ/クライアント自動分割を備えたWebフレームワークの設計と実装
稲津和磨; 岩崎英哉
情報処理学会論文誌 プログラミング, 情報処理学会, 3, 4, 1-15, Sep. 2010, Peer-reviwed, 近年Google Mapsなどに代表される，Ajaxと呼ばれる手法を用いたWebアプリケーションが増加している．Ajaxを用いたWebアプリケーションはサーバ側とクライアント側で動作する2つのプログラムにより構成され，それらが協調して動作する．そのため，煩雑な通信処理を記述する必要があり，さらには，それぞれの実装言語が多くの場合は異なっているため，プログラミングが非常に煩雑になる．そこで本論文では，開発効率の向上を目的として，JavaScriptに基づくプログラム言語でWebアプリケーションを1つのプログラムとして記述し，処理の柔軟な分割を可能とするフレームワークを提案する．また，そのプログラム言語で記述されたプログラムを読み込み，サーバ側で動作するソースコードとクライアント側で動作するソースコードを出力するような機構を設計し，実装した．提案機構は，与えられたプログラムを解析し各構文要素がサーバとクライアントのどちらで実行するべきかを決定する．その際，分割方針を指定することで，同じソースコードから異なる分割を得ることができる．同じ動作をするWebアプリケーションを，提案機構と既存の手法のそれぞれを用いて記述し，プログラムを比較して記述性が向上していることを確認した．また，提案機構によるオーバヘッドは，Webアプリケーションで行われる一般的な処理については問題ない程度の小さなものであることを確認した．Ajax based web applications such as Google Maps have increased in recent years. An Ajax application is composed of the server side program and the client side program. Usually these programs are written in different programming languages. Furthermore, communications between the server and the client have to be explicitly described. For this reason, development of web applications is a very complicated task. To solve this problem, we proposes a framework that enables the user to write a web application as a single program. We have implemented a system that partition such a program into both the server side program and the client side one. It decides which parts of a source program should be executed at the client side or at the server side based on a policy given by the user. We confirmed that our framework makes the development of web applications easier, by comparing a program using our framework with a program using an existing method for the same application. Although our framework causes overhead in execution time, it is acceptable for general web applications.
Scientific journal, Japanese

ブラウザで動作するウェブアプリケーションのソースコード隠蔽機構
折戸隆洋; 岩崎英哉
情報処理学会論文誌 プログラミング, 3, 4, 16-26, Sep. 2010, Peer-reviwed
Scientific journal, Japanese

Improved Replication-Based Incremental Garbage Collection for Embedded Systems
Tomoharu Ugawa; Hideya Iwasaki; Taiichi Yuasa
Proc. 2010 International Symposium on Memory Management (ISMM 2010), 73-82, Jun. 2010, Peer-reviwed, We have developed an incremental compacting garbage collector for embedded Java systems. The collector divides the heap into equal sized pages and uses the segregated free lists for fast allocation. Collectors that have such a heap layout have a problem of fragmentation in allocating objects larger than the page size. We solve this problem by using the replication-based incremental compaction. The compactor evacuates all objects in one area, the evacuation area, of the heap, thereby creating a large chunk of free space. We developed an algorithm for choosing the evacuation area that effectively cures fragmentation. The compactor does not use any read-barriers. Instead, it uses a technique similar to the replication-based incremental copying collection. This needs forwarding pointers for all evacuated objects. Rather than introducing an extra field for each object, we use a hash table to store forwarding pointers. Evaluation of this garbage collector implemented in Sun's J2ME Java Virtual Machine showed that all the benchmarks used were able to run without memory starvation using the heap sizes of only 151%-286% of the maximum amount of live data plus 8 KB of the hash table. Experiments on a desktop computer, though it is not a platform for embedded systems, showed that the maximum pause time was shorter than 200 μs, which was comparable to that of our implementation of the snapshot-at-the-beginning collector without compaction. On an ARM processor, the runtime overhead was 1%-16% with 8.0% on average compared to the mark-sweep collector. © 2010 ACM.
International conference proceedings, English

A Skeletal Parallel Framework with Fusion Optimizer for GPGPU Programming
Shigeyuki Sato; Hideya Iwasaki
Proc. 7th Asian Symposium on Programming Languages and Systems (APLAS 2009), Lecture Notes in Computer Science 5904, SPRINGER-VERLAG BERLIN, 79-94, Dec. 2009, Peer-reviwed, Although today's graphics processing units (GPUs) have high performance and general-purpose computing on GPUs (GPGPU) is actively studied, developing GPGPU applications remains difficult for two reasons. First, both parallelization and optimization of GPGPU applications is necessary to achieve high performance. Second, the suitability of the target application for GPGPU must be determined, because whether at application performs well with GPGPU heavily depends on its inherent properties, which are not obvious from the source code. To overcome these difficulties, we developed a skeletal parallel programming framework for rapid GPGPU application developments. It enables program tin to easily write GPGPU applications and rapidly test them because it generates programs for both GPUs and CPUs from the same source code. It also provides an optimization mechanism based on fusion transformation. Its effectiveness was confirmed experimentally.
International conference proceedings, English

A Parallel Skeleton Library for Multi-core Clusters
Yuki Karasawa; Hideya Iwasaki
Proc. 38th International Conference on Parallel Processing (ICPP 2009), 84-91, Sep. 2009, Peer-reviwed, A parallel skeleton library is a collection of parallel computations that abstract generic and recurring patterns within parallel programs and conceal parallel behaviors as skeletons. It enables users to develop parallel programs as if they were sequential ones by composing suitable skeletons. However, many existing parallel skeleton libraries for distributed environments do not take into account the potential performance of multicore CPUs, because they operate under the premise that each node (computer) has a single-core CPU. To resolve this problem, this paper proposes the design and implementation of a parallel skeleton library for multi-core clusters. The proposed library adopts a two-stage dynamic task scheduling strategy
the first is among nodes and the second is among cores. This scheduling strategy enables the library to appropriately balance the load both between nodes and cores. The library also dynamically fuses successive skeleton calls to reduce the cost of control flows and increase the locality of data. The proposed skeletons are implemented from scratch for matrices within a parallel skeleton library called SkeTo by using the template techniques in C++ language. We confirmed that our implementation was efficient through various benchmarks. © 2009 IEEE.
International conference proceedings, English

Parallel Skeletons for Variable-Length Lists in SkeTo Skeleton Library
Haruto Tanno; Hideya Iwasaki
Proc. 15th International Euro-Par Conference (Euro-Par 2009), Lecture Notes in Computer Science 5704, SPRINGER-VERLAG BERLIN, 666-677, Aug. 2009, Peer-reviwed, Skeletal parallel programming is a promising solution to simplify parallel programming. The approach involves providing genetic and recurring data structures like lists and parallel computation patterns as skeletons that conceal parallel behaviors. However, when we focus on lists, which are usually implemented as one-dimensional arrays, their length is restricted and fixed in existing data parallel skeleton libraries. Due to this restriction, many problems cannot be coded using parallel skeletons. To resolve this problem, this paper proposes parallel skeletons for lists of variable lengths and their implementation within a parallel skeleton library called SkeTo. The proposed skeletons enable us to solve a wide range of problems including those of twin primes, Knight's tour, and Mandelbrot set calculations with SkeTo. We tested and confirmed the efficiency of our implementation of variable-length lists through various experiments.
International conference proceedings, English

Haskellプログラムの開発を支援するGHCiデバッガフロントエンド
根岸純一; 岩崎英哉
情報処理学会論文誌 プログラミング, 2, 3, 48-56, Jul. 2009, Peer-reviwed
Scientific journal, Japanese

Kenro: A Virtual Machine Monitor Mostly Described in Haskell
Yoshihiro Oyama; Yoshiki Kaneko; Hideya Iwasaki
Proc. 2009 ACM Symposium on Applied Computing (SAC 2009), 1940-1941, Mar. 2009, Peer-reviwed, We report on our experiences developing a tiny virtual machine monitor, named Kenro, mostly in Haskell as a concrete example of low-level, hardware-dependent system software. The development of Kenro was greatly helped by features of Haskell, including higher-order functions, strong static typing, and the automatic memory management. We describe the advantages and limitations of Haskell studied through our development experience. Copyright 2009 ACM.
International conference proceedings, English

Tuning Mechanisms for Two Major Parameters of Apache Web Servers
Akiyoshi Sugiki; Kenji Kono; Hideya Iwasaki
Software - Practice and Experience, WILEY-BLACKWELL, 38, 12, 1215-1240, Oct. 2008, Peer-reviwed, Apache web servers are widely used as stand-alone servers or front-ends in multi-tiered web servers. Despite the wide availability of software, it is quite difficult for many administrators to properly configure their web servers. In particular, setting the performance-related parameters is an error-prone and time-consuming task because their values heavily depend on the server environment. In this paper, two mechanisms are described for automatically tuning two performance-related parameters of Apache web servers: KeepAliveTimeout and MaxClients. These mechanisms are easy to deploy because no modifications to the server or the operating system are required. Moreover, they are parameter specific. Although interference between KeepAliveTimeout and MaxClients is inevitable, the tuning mechanisms minimize the correlation by using almost completely independent metrics. Experimental results show that these mechanisms work well for two different workloads; the parameter values are close to optimal and can adapt to workload changes. Copyright (C) 2007 John Wiley & Sons, Ltd.
Scientific journal, English

純関数型言語の処理系における効率的な枝刈り機構の実装
田村和博; 高野保真; 岩崎英哉
情報処理学会論文誌 プログラミング, 情報処理学会, 1, 2, 28-41, Sep. 2008, Peer-reviwed, 実行効率の良い探索プログラムを書くためには，結果に寄与しない計算を除去する枝刈りが有効であるが，一般に，簡潔なプログラム構造を保ったまま枝刈りの記述をすることは難しい．この問題点を解決するために，Improving Sequence（IS）というデータ構造を用いる手法が提案され，有効性が確認されている．ISとは，ある全的に定義された推移的な二項関係に従い，要求駆動によって単調に最終結果へ近づいていく近似値の列のことである．ISを用いたプログラムでは，枝刈りをするか否かの判断に近似値を用いることができる．従来の純関数型言語上のISの実装はライブラリによるものだったので，近似値の数に比例したヒープ領域を必要とし，効率があまり良くないという問題点があった．この問題点を解決するため，本論文では，ISの近似値が持つ単調性に着目し，また，近似値が枝刈りの判断にのみ用いられ，中間データとしての役割しか持たないことを前提として，純関数型言語において，定数領域しかヒープを消費しないISの実装を提案する．提案手法の効果を確認するため，Glasgow Haskell Compilerに実装を施し，ナップサック問題など，いくつかのプログラムで実験を行った．その結果，問題によってばらつきはあるものの，メモリ消費量において3%～75%程度の減少が見られ，安定的に改善できることが確認できた．また，メモリ消費量を削減することで，多くの場合に実行時間を改善できることも確認できた．Pruning unnecessary computations increases the efficiency of search programs. However, in general, it is hard to write a program that performs pruning while retaining program clarity. A mechanism called Improving Sequence (IS for short) helps the programmers write clear program for pruning computations. An IS is a sequence of approximations that are gradually improved based on a binary relation and approach the final value. Each approximation value can be used to decide whether further computations beyond the approximation can be pruned or not. Existing implementation of an IS on a purely functional language is library-based one, thus much heap space that is proportional to the number of approximations is consumed. To solve this problem, this paper proposes an efficient implementation of an IS that consumes only the constant space within the heap space. The proposed implementation is based on the observation that the approximations with an IS is monotonic and each approximation is used only in the judgment of pruning. We implemented the proposed idea in the Glasgow Haskell Compiler, and made some experiments by running some search programs that use ISes. The results show that the amount of memory consumption is reduced by 3-75%, depending on the program, and the execution time is also reduced in many cases.
Scientific journal, Japanese

Parallel Skeletons for Sparse Matrices in SkeTo Skeleton Library
Yuki Karasawa; Hideya Iwasaki
情報処理学会論文誌：プログラミング, 49, SIG 3 (PRO 36), 1-15, Mar. 2008, Peer-reviwed
Scientific journal, English

A Sandbox with Dynamic Policy Based on Execution Contexts of Applications
Tomohiro Shioya; Yoshihiro Oyama; Hideya Iwasaki
Proc. 12th Asian Computing Science Conference (ASIAN 2007), Lecture Notes in Computer Science 4846, SPRINGER-VERLAG BERLIN, 297-311, Dec. 2007, Peer-reviwed, We propose a sandbox system that dynamically changes its behavior according to the application's execution context. Our system allows users to give different policies, each of which specifies permitted system calls, depending on the user functions in which the target application is executing. The target application can be given less privilege than would be possible with other single-policy sandbox systems. We implemented the sandbox by using LKM (Loadable Kernel Module) of Linux that intercepts the system call issued by the application process. We experimentally demonstrated the effectiveness of the sandbox.
International conference proceedings, English

非同期処理のための JavaScript マルチスレッドフレームワーク
牧大介; 岩崎英哉
情報処理学会論文誌：プログラミング, 48, SIG 12 (PRO 34), 1-18, Aug. 2007, Peer-reviwed
Scientific journal, Japanese

Automatic Tuning of the Keep-alive Parameter of Web Servers based on Request-waiting Intervals
SUGIKI Akiyoshi; KONO Kenji; IWASAKI Hideya; Akiyoshi Sugiki; Kenji Kono; Hideya Iwasaki; Department of Computer Science Graduate School of Electro-Communications The University of Electro-Communications; Department of Information and Computer Science Keio University; Department of Computer Science The University of Electro-Communications
Computer Software, Japan Society for Software Science and Technology, 24, 2, 68-78, Apr. 2007, Peer-reviwed, Manual parameter-tuning of Internet servers causes high administrative costs because it requires administrator's expertise and huge amounts of time. The keep-alive parameter, which is one of major parameters in web servers, may cause severe degradation if it is not set properly. In this paper, we present an automatic tuning technique of the keep-alive parameter. Our mechanism adjusts the parameter without administrator's intervention so as to maintain active connections between clients and a server while closing inactive connections by observing request-waiting intervals. We implemented a prototype for Apache web server. Experimental results show that our prototype automatically adjusted the parameter and successfully yielded the nearly optimal server performance on two different workloads.
Scientific journal, Japanese

アプリケーション層プロトコルの記述に基づく拡張性に優れたプロトコル処理コード生成系
阿部勝幸; 岩崎英哉; 河野健二
コンピュータソフトウェア, 24, 2, 150-163, Apr. 2007, Peer-reviwed
Scientific journal, Japanese

Instantly Turning a Naive Exhaustive Search into Three Efficient Searches with Pruning
Takeshi Morimoto; Yasunao Takano; Hideya Iwasaki
Proc. 9th International Symposium on Practical Aspects of Declarative Languages (PADL 2007), Lecture Notes in Computer Science 4354, SPRINGER-VERLAG BERLIN, 65-79, Jan. 2007, Peer-reviwed, A technique is described that enables purely functional programmers to write efficient search programs in the same form as simple and naive but; exhaustive search programs. It performs pruning while retaining a simple program form by exploiting a lazy data structure, an improving sequence, which is a monotonical sequence of approximation values that approach the final value. If some approximation value in an improving sequence has sufficient information to yield the result of some part of the program, the computations that produce the values remaining after the approximation can be pruned. On the basis of an exhaustive search program, which can be regarded as the specification of a problem, three important search algorithms, namely best-first, depth-first branch-and-bound, and iterative-deepening, can be obtained by using suitable functions defined on improving sequences. Two specific examples, the eight puzzle problem and the knapsack problem in Haskell, demonstrate that the technique is practical.
International conference proceedings, English

要求駆動計算における要求粒度調節機構
森本武資; 岩崎英哉
情報処理学会論文誌, 47, 12, 3277-3286, Dec. 2006, Peer-reviwed
Scientific journal, Japanese

A Library of Constructive Skeletons for Sequential Style of Parallel Programming
Kiminori Matsuzaki; Kento Emoto; Hideya Iwasaki; Zhenjiang Hu
Proc. First International Conference on Scalable Information Systems (InfoScale 2006), CDROM, May 2006, Peer-reviwed, With the increasing popularity of parallel programming environments such as PC clusters, more and more sequential programmers, with little knowledge about parallel architectures and parallel programming, are hoping to write parallel programs. Numerous attempts have been made to develop high-level parallel programming libraries that use abstraction to hide low-level concerns and reduce difficulties in parallel programming. Among them, libraries of parallel skeletons have emerged as a promising way towards this direction. Unfortunatefy, these libraries are not well accepted by sequential programmers, because of incomplete elimination of lower-level details, ad-hoc selection of library functions, unsatisfactory performance, or lack of convincing application examples. This paper addresses principle of designing skeleton libraries of parallel programming and reports implementation details and practical applications of a skeleton library SkeTo. The SkeTo library is unique in its feature that it has a solid theoretical foundation based on the theory of Constructive Algorithmes, and is practical to be used to describe various parallel computations in a sequential manner. © 2006 ACM.
International conference proceedings, English

A Practical Approach to Automatic Parameter-Tuning of Web Servers
Akiyoshi Sugiki; Kenji Kono; Hideya Iwasaki
Proc. 10th Asian Computing Science Conference (ASIAN 2005), Lecture Notes in Computer Science 3818, SPRINGER-VERLAG BERLIN, 146-159, Dec. 2005, Peer-reviwed, This paper presents a practical approach to automatically tuning the parameters of the Apache Web server. In particular, two significant parameters, KeepAliveTimeout and MaxClients, are dealt with. The notable features of our approach are twofold. First, it is easy to deploy because no modifications to Apache or the underlying operating system are required. Second, our approach is based on the detailed analysis on how each parameter affects the server's behavior. Experimental results demonstrate that our prototype works well on different workloads; it can discover almost optimal values and quickly adapt to workload changes.
Scientific journal, English

最適化機構を持つC++並列スケルトンライブラリ
明石良樹; 松崎公紀; 岩崎英哉; 筧一彦; 胡振江
コンピュータソフトウェア, 22, 3, 214-221, Jul. 2005, Peer-reviwed
Scientific journal, Japanese

需要変化に動的に対応する伸縮自在サーバ群の基本機構
揚妻匡邦; 河野健二; 岩崎英哉; 益田隆司
電子情報通信学会論文誌 D-I, The Institute of Electronics, Information and Communication Engineers, J88-D-1, 4, 767-779, Apr. 2005, Peer-reviwed, インターネット上では様々なサービスが展開されており, 社会的な基盤としてその役割はますます重要になっている.インターネット上のサービスへの需要が増加すると, サービスを提供するサーバの負荷が高まり, サービスの遅延や最悪の場合サービスの一時停止などといったサービスの質の低下へとつながる.サービスの質の低下を抑える方法として, 一般に同じサービスを提供することができる計算機を複数台用意し, サービスへの需要を各計算機へと分散する手法が用いられている.しかし, インターネット上のサービスへの需要は常に変動しているため, あらかじめ需要を予測して計算機資源を設置することは難しい.そこで本論文では, サービスへの需要の増減に応じ, サービスを提供する計算機資源の総量を自動的に調節する基盤を提案する.本基盤により構成されるサーバ群を伸縮自在サーバ群と呼ぶ.伸縮自在サーバ群では, 複数の計算機が動いており, 互いにPeer-to-Peer方式を用いて通信し, サービスを提供する計算機の増減を行う.本論文では, 伸縮自在サーバ群と, 伸縮自在サーバ群上でサービスを提供する計算機を増減させるための基本機構を提案し, その有効性をシミュレーションを用いて検証する.
Scientific journal, Japanese

A New Parallel Skeleton for General Accumulative Computations
Hideya Iwasaki; Zhenjiang Hu
International Journal of Parallel Programming, SPRINGER/PLENUM PUBLISHERS, 32, 5, 389-414, Oct. 2004, Peer-reviwed, Skeletal parallel programming enables programmers to build a parallel program from ready-made components (parallel primitives) for which efficient implementations are known to exist, making both the parallel program development and the parallelization process easier. Constructing efficient parallel programs is often difficult, however, due to difficulties in selecting a proper combination of parallel primitives and in implementing this combination Without having unnecessary creations and exchanges of data among parallel primitives and processors. To overcome these difficulties, we propose a powerful and general parallel skeleton, accumulate, which can be used to naturally code efficient Solutions to problems as well as be efficiently implemented in parallel using Message Passing Interface (MPI).
Scientific journal, English

A Fusion-Embedded Skeleton Library
Kiminori Matsuzaki; Kazuhiko Kakehi; Hideya Iwasaki; Zhenjiang Hu; Yoshiki Akashi
Proc. 10th International Euro-Par Conference (Euro-Par 2004), Lecture Notes in Computer Science 3149, SPRINGER-VERLAG BERLIN, 644-653, Aug. 2004, Peer-reviwed, This paper addresses a new framework for designing and implementing skeleton libraries, in which each skeleton should not only be efficiently implemented as is usually done, but also be equipped with a structured interface to combine it efficiently with other skeletons. We illustrate our idea with a new skeleton library for parallel programming in C++. It is simple and efficient to use just like other C++ libraries. A distinctive feature of the library is its modularity: Our optimization framework treats newly defined skeletons equally to existing ones if the interface is given. Our current experiments are encouraging, indicating that this approach is promising both theoretically and in practice.
Scientific journal, English

ファイル移送に基づく分散ファイルシステムの設計と実装
村田光一; 河野健二; 岩崎英哉; 益田隆司
コンピュータソフトウェア, 21, 4, 43-48, Jun. 2004, Peer-reviwed
Scientific journal, Japanese

枝刈り機構とメモ化機構をもつ言語
森本武資; 岩崎英哉; 竹内郁雄
コンピュータソフトウェア, 21, 4, 55-60, Jun. 2004, Peer-reviwed
Scientific journal, Japanese

An Interactive Proofreading System for Inappropriately Selected Words on Using Predictive Text Entry
Hideya Iwasaki; Kumiko Tanaka-Ishii
Proc. 1st International Joint Conference on Natural Language Processing (IJCNLP 2004), Lecture Notes in Artificial Intelligence 3248, SPRINGER-VERLAG BERLIN, 755-764, Mar. 2004, Peer-reviwed, Predictive text entry systems on computers like kana-to-kanji conversion provide a mechanism that enables users to select among possible words for a given input. Mistakes in selection are relatively common, and they introduce real-word errors. A proofreading system is thus needed to detect and correct real-word errors on a computer without imposing troublesome operations on users. To this end, a practical proofreading system for Japanese text is proposed. The system automatically detects possible real-word homonym errors, and for each detected word, suggests substitution candidates of the same pronunciation. The user can either choose the most appropriate one or leave the original untouched. The system uses an algorithm based on the Naive Bayesian method. Although the proofreading system was implemented for homonym errors in Japanese text, its design concept and algorithm are also applicable to other languages. The client program of the proofreading system is implemented on the Emacs text editor and works in real time.
Scientific journal, English

Self-configurable Mirror Servers for Automatic Adaptation to Service Demand Fluctuation
Masakuni Agetsuma; Kenji Kono; Hideya Iwasaki
Proc. 8th Asian Computing Science Conference (ASIAN 2003), Lecture Notes in Computer Science 2896, SPRINGER-VERLAG BERLIN, 18-32, Dec. 2003, Peer-reviwed, Various network services are becoming more and more important serving roles in the social infrastructure in the Internet. The more clients a service has, the more load the server has, which obviously lowers the quality of service. To balance load and maintain quality, multiple servers (mirror servers) are commonly provided that are able to provide access to the same service. However, it is difficult to estimate the required number of mirror servers in advance. To overcome this, we propose a new concept called self-configurable server groups and discuss its basic mechanism where all server nodes communicate with one another in a peer-to-peer style to adjust to the expected number of servers. We also demonstrate the effectiveness of the proposed mechanism via some simulations.
Scientific journal, English

モバイルコード技術によるアプリケーション層プロトコルのユーザ透過な配布機構
揚妻匡邦; 河野健二; 岩崎英哉; 益田隆司
電子情報通信学会論文誌 D-I, The Institute of Electronics, Information and Communication Engineers, J86-D-1, 6, 389-401, Jun. 2003, Peer-reviwed
Scientific journal, Japanese

Developing a Lisp-based Preprocessor for TEX Documents
Hideya Iwasaki
Software - Practice and Experience, JOHN WILEY & SONS LTD, 32, 14, 1345-1363, Nov. 2002, Peer-reviwed, TEX allows users to define a macro that abstracts a sequence of typesetting commands. However, defining macros is not easy for most users, because the mechanism of macro expansion in TEX is complicated. As a remedy for this situation, a new system that enables users to define macros for TEX documents as Lisp programs has been developed. The system acts as a preprocessor for TEX; given a document that contains Lisp programs as S-expressions, the system expands each S-expression on the basis of Lisp's evaluation rules, thus generating an ordinary TEX document. The system is very flexible and easy-to-use, thanks to the underlying language's general-purpose data structure, i.e. the S-expression. applicative order evaluation, and rich set of predefined functions. This paper also demonstrates that the proposed system is really, effective for practical use by giving some concrete examples of Lisp macros, some of which are difficult to define in terms of TEX commands. The system is currently implemented on the Emacs Lisp, and a user-friendly environment is thus available in the Emacs text editor. Copyright (C) 2002 John Wiley Sons, Ltd.
Scientific journal, English

Characterizing Feasible Pattern Sets with Minimum Number of Breaks
Ryuhei Miyashiro; Hideya Iwasaki; Tomomi Matsui
Proc. 4th International Conference on the Practice and Theory of Automated Timetabling (PATAT 2002), Lecture Notes in Computer Science 2740, 78-99, Aug. 2002, Peer-reviwed
International conference proceedings, English

An Accumulative Parallel Skeleton for All
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Proc. 2002 European Symposium on Programming (ESOP 2002), Lecture Notes in Computer Science 2305, SPRINGER-VERLAG BERLIN, 83-97, Apr. 2002, Peer-reviwed, Parallel skeletons intend to encourage programmers to build a parallel program from ready-made components for which efficient implementations are known to exist, making the parallelization process simpler. However, it is neither easy to develop efficient parallel programs using skeletons nor to use skeletons to manipulate irregular data, and moreover there lacks a systematic way to optimize skeletal parallel programs. To remedy this situation, we propose a novel parallel skeleton, called accumulate, which not only efficiently describes data dependency in computation but also exhibits nice algebraic properties for manipulation. We show that this skeleton significantly eases skeletal parallel programming in practice, efficiently manipulating both regular and irregular data, and systematically optimizing skeletal parallel programs.
Scientific journal, English

Flattening Transformation for Efficient Segmented Computation - Segmented Diffusion Theorem.
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
The Third Asian Workshop on Programming Languages and Systems, APLAS'02, Shanghai Jiao Tong University, Shanghai, China, November 29 - December 1, 2002, Proceedings, 246-257, 2002, Peer-reviwed

Efficient Parallel Skeletons for Nested Data Structures
Tomonari Takahashi; Hideya Iwasaki; Zhenjiang Hu
Proc. 2001 International Conference on Parallel and Distributed Processing Techniques and Applications (PDPTA 2001), C S R E A PRESS, 728-734, Jun. 2001, Peer-reviwed, Skeleton programming enables programmers to build parallel programs easier by providing efficient ready-made skeletons. In addition to primitive skeletons, diffusion skeleton has been proposed for rather complicated problems, abstracting a good combination of primitive skeletons. However, since they equally treat each element in target data the existing skeletons are not always efficient for nested data structure where sizes of inner elements may be remarkably different. To resolve this problem, this paper proposes a new parallel skeleton, segmented diffusion, specially for nested data structure. The proposed skeleton is a nested version of the diffusion skeleton and similarly provides a proper combination of primitive nested skeletons. This paper also describes implementation of the skeleton and some experimental results, showing that the proposed skeleton is efficient and can be applied to a wider class of problems.
International conference proceedings, English

Diffusion after Fusion - Deriving Efficient Parallel Algorithms
Raku Shirasawa; Zhenjiang Hu; Hideya Iwasaki
Proc. 2001 International Conference on Parallel and Distributed Processing Techniques and Applications (PDPTA 2001), C S R E A PRESS, 735-741, Jun. 2001, Peer-reviwed, Parallel skeletons are ready-made components whose efficient implementations are known to exist. Using them programmers can develop parallel programs without concerning about lower level of implementation. However, programmers may often suffer from the difficulty to choose a proper combination of parallel skeletons so as to construct efficient parallel programs. In this paper. we propose a new method, namely diffusion after fusion, which can not only guide a programmer to develop efficient parallel programs in a systematic way, but also be suitable for optimization of skeleton parallel programs. In this method, first we remove unnecessary intermediate data structure by fusion without being conscious of parallelism. Then we parallelize the fused program by diffusion. Using the Line-of-sight problem, this paper shows that the proposed method is quite effective.
International conference proceedings, English

漸次的組化と融合による関数プログラムの最適化
岩崎英哉; 胡振江; 武市正人
コンピュータソフトウェア, 18, 0, 46-59, Jan. 2001, Peer-reviwed
Scientific journal, Japanese

Context-Sensitive Detection and Correction of Homonym Errors in Japanese Texts
Hideya Iwasaki; Kumiko Tanaka-Ishii; Kei Tateno; Masato Takeichi
Proc. 5th International Workshop on Information Retrieval with Asian Languages (IRAL 2000), Association for Computing Machinery, Inc, 215-216, Sep. 2000, Peer-reviwed, In Japanese and Chinese, the use of kanji characters has produced words with many homonyms. Thus, the correct 'spelling' (kanji) for a word can depend on its context. Computer text entry systems provide a mechanism for users to choose between possible spellings, but mistakes are relatively common. We propose a new context-sensitive algorithm to correct this kind of spelling error. The algorithm detects errors in input text and suggests alternative spellings to the user. Our experimental results have shown maximally about 98~ of accuracy rate.
International conference proceedings, English

Diff: A Powerful Parallel Skeleton
Seiji Adachi; Hideya Iwasaki; Zhenjiang Hu
Proc. 2000 International Conference on Parallel and Distributed Processing Techniques and Applications (PDPTA 2000), C S R E A PRESS, 2175-2181, Jun. 2000, Peer-reviwed, Skeleton parallel programming encourages programmers to build a parallel program from ready-made components for which efficient implementations are known to exist, making both the parallel program development and the parallelization process easier. However, programmers often suffer from the difficulty to choose a proper combination of parallel primitives so as to construct efficient parallel programs. To overcome this difficulty, we propose a new powerful parallel skeleton diff derived from the diffusion theorem, showing how it can be used to naturally code efficient solutions to problems, and how it can be efficiently implemented in parallel using MPI (Message Passing Interface).
International conference proceedings, English

プログラム融合変換の実用的有効性の検証
尾上能之; 胡振江; 岩崎英哉; 武市正人
コンピュータソフトウェア, 17, 3, 81-85, May 2000, Peer-reviwed
Scientific journal, Japanese

初心者入門用言語「若葉」の言語仕様と処理系の実装
吉良智樹; 並木美太郎; 岩崎英哉
情報処理学会論文誌：プログラミング, 40, SIG10(PRO5), 28-38, Dec. 1999, Peer-reviwed
Scientific journal, Japanese

Calculating Accumulations
Zhenjiang Hu; Hideya Iwasaki
New Generation Computing, SPRINGER, 17, 2, 153-173, Jun. 1999, Peer-reviwed, The accumulation strategy consists of generalizing a function over an algebraic data structure by inclusion of an extra parameter, an accumulating parameter, for reusing and propagating intermediate results. However, there remain two major difficulties in this accumulation strategy. One is to determine where and when to generalize the original function. The other, surprisingly not yet receiving its worthy consideration, is how to manipulate accumulations. To overcome these difficulties, we propose to formulate accumulations as higher order catamorphisms, and provide several general transformation rules for calculating accumulations (i.e., finding and manipulating accumulations) by calculation-based (rather than a search-based) program transformation methods. Some examples are given for illustration.
Scientific journal, English

Diffusion: Calculating Efficient Parallel Programs
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Proc. 1999 ACM SIGPLAN International Workshop on Partial Evaluation and Semantics-Based Program Manipulation (PEPM 1999), 85-94, Jan. 1999, Peer-reviwed
International conference proceedings, English

Construction of Bilingual Dictionary Intermediated by a Third Language
田中(石井)久美子; 梅村恭司; 岩崎英哉
情報処理学会論文誌, Information Processing Society of Japan (IPSJ), 39, 6, 1915-1924, Jun. 1998, Peer-reviwed, When putting two dictionaries, such as Japanese-English and English-French, together into a bilingual dictionary, the Japanese-French dictionary, it is necessary to discriminate equivalencies from inappropriate words caused by the ambiguity in the third language (which is English in the example).We propose a method to treat this by exploiting the structures of dictionaries to measure the similarity of the meanings of words. The resulting dictionary is a word-to-word bilingual dictionary of nouns, verbs, adjectives, and can be used to refine the entries and equivalencies in published bilingual dictionaries.
Scientific journal, Japanese

Towards Manipulation of Mutually Recursive Functions
Hideya Iwasaki; Zhenjiang Hu; Masato Takeichi
Proc. 3rd Fuji International Symposium on Functional and Logic Programming (FLOPS 1998), 61-79, Apr. 1998, Peer-reviwed
International conference proceedings, English

関係代数による UNITY ループの意味づけ
徐良為; 武市正人; 岩崎英哉
情報処理学会論文誌, 39, 3, 646-655, Mar. 1998, Peer-reviwed
Scientific journal, Japanese

Promotional Transformation of Functional Programs with Accumulative Parameters
岩崎英哉; 胡振江
情報処理学会論文誌, Information Processing Society of Japan (IPSJ), 39, 3, 664-673, Mar. 1998, Peer-reviwed, In order to gain the efficiency of functional programs, it is important to fuse the composition and eliminate intermediate data structures passed through the composition. Constructive Algorithmics is one of the promising approaches to this problem. This paper focuses on functions with accumulative parameters, and discusses two transformation strategies -one based on higher-order catamorphisms and the other based on hylomorphisms. It is shown that programs which can be transformed by the former can be also transformed by the latter. The result of this paper shows that program transformation system based on Constructive Algorithmics has only to take into account the strategy by hylomorphisms.
Scientific journal, Japanese

Relational Semantics for Locally Nondeterministic Programs
Liangwei Xu; Masato Takeichi; Hideya Iwasaki
New Generation Computing, SPRINGER VERLAG, 15, 3, 339-361, Sep. 1997, Peer-reviwed, Introducing nondeterministic operators in a conventional deterministic language gives rise to various semantic difficulties. One of the problems is that there has been no semantic domain that is wholly satisfactory for denoting nondeterministic programs.
In this paper, we propose an approach based on relational algebra. We divide the semantics of a nondeterministic program into two parts. The first part concerns the angelic aspect of programs and the second part concerns the demonic aspect of programs. Because each semantic function used in these parts is monotonic with respect to an ordering on relations, the existence of the fixed points of recursively defined nondeterministic programs is ensured.
Scientific journal, English

Clustering Co-occurrence Graph based on Transitivity
Kumiko Tanaka-Ishii; Hideya Iwasaki
Proc. 5th Workshop on Very Large Corpora (WVLC 1997), 91-100, Aug. 1997, Peer-reviwed
International conference proceedings, English

Tupling Calculation Eliminates Multiple Data Traversals
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi; Akihiko Takano
Proc. 1997 ACM SIGPLAN International Conference on Functional Programming (ICFP 1997), ACM Press, 164-175, Jun. 1997, Peer-reviwed
International conference proceedings, English

Formal Derivation of Efficient Parallel Programs by Construction of List Homomorphisms
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
ACM Transactions on Programming Languages and Systems, ASSOC COMPUTING MACHINERY, 19, 3, 444-461, May 1997, Peer-reviwed, It has been attracting much attention to make use of list homomorphisms in parallel programming because they ideally suit the divide-and-conquer parallel paradigm, However, they have been usually treated rather informally and ad hoc in the development of efficient parallel programs. What is worse is that some interesting functions, e.g., the maximum segment sum problem, are basically not list homomorphisms. In this article, we propose a systematic and formal way for the construction of a list homomorphism for a given problem so that an efficient parallel program is derived. We show, with several well-known but nontrivial problems, how a straightforward, and ''obviously'' correct, but quite inefficient solution to the problem can be successfully turned into a semantically equivalent ''almost list homomorphism.'' The derivation is based on two transformations, namely tupling and fusion, which are defined according to the specific recursive structures of list homomorphisms.
Scientific journal, English

A Calculational Fusion System HYLO
Yoshiyuki Onoue; Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Proc. IFIP TC2 Working Conference on Algorithmic Languages and Calculi, CHAPMAN & HALL, 76-106, Feb. 1997, Peer-reviwed, Fusion, one or the most useful transformation tactics for deriving efficient programs, is the process whereby separate pieces of programs are fused into a single one, leading to an efficient program without intermediate data structures produced. In this paper, we report our on-going investigation on the design and implementation of an automatic transformation system HYLO which performs fusion transformation in a more systematic and more general way than any other systems. The distinguished point of our system is its calculational feature based on simple application of transformation laws rather than traditional search-based transformations.
International conference proceedings, English

An Extension of the Acid Rain Theorem
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Proc. 2nd Fuji International Workshop on Functional and Logic Programming (FLOPS 1996), 91-105, Nov. 1996, Peer-reviwed
International conference proceedings, English

Construction of List Homomorphisms by Tupling and Fusion
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Proc. Mathematical Foundations of Computer Science (MFCS 1996), Lecture Notes in Computer Science 1113, 407-418, Sep. 1996, Peer-reviwed
International conference proceedings, English

Extraction of Lexical Translations from Non-Aligned Corpora
Kumiko Tanaka; Hideya Iwasaki
Proc. 16th International Conference on Computer Linguistics (COLING 1996), 580-585, Aug. 1996, Peer-reviwed
International conference proceedings, English

Formal Derivation of Parallel Program for 2-Dimensional Maximum Segment Sum Problem
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Proc. Annual European Conference on Parallel Processing (EuroPar 1996), Lecture Notes in Computer Science 1123, 553-562, Aug. 1996, Peer-reviwed
International conference proceedings, English

Deriving Structural Hylomorphisms from Recursive Definitions
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Proc. 1996 ACM SIGPLAN International Conference on Functional Programming (ICFP 1996), 73-82, May 1996, Peer-reviwed
International conference proceedings, English

Cheap tupling in calculational form
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
Lecture Notes in Computer Science (including subseries Lecture Notes in Artificial Intelligence and Lecture Notes in Bioinformatics), Springer Verlag, 1140, 471-472, 1996, Peer-reviwed, In functional programming, a program prog is usually expressed as compositions of transformations over data structures while each transformation is defined by a recursion Ri traversing over its input data structure, namely prog = R1 o… oRn.
International conference proceedings, English

Making Kanji Skeleton Fonts through Compositing Parts
田中哲朗; 岩崎英哉; 長橋賢児; 和田英一
情報処理学会論文誌, Information Processing Society of Japan (IPSJ), 36, 9, 2122-2131, Sep. 1995, Peer-reviwed, Most of Kanji characters consist of primitive parts, such as "hen"s and "tsukuri"s. We propose a font system which automatically generates Kanji fonts from their abstract joint definitions. Although the size of parts have to be extended or reduced through the composition process, the use of skeleton fonts enables us to change their sizes without redesigning them for many sizes. In this paper, we handle three types of composition, that is, horizontal, vertical and insertion compositions. We represented all characters in JIS X0208 by the combination of these three types, which reduces the design cost considerably. We tried several horizontal composition methods to get better designed fonts, and extended the best method to vertical and insertion compositions. Through these methods, we made a skeleton font set which includes all 12156 JIS X0208 and X0212 Kanji characters. Although the algorithm is simple, the quality of generated fonts is tolerably high.
Scientific journal, Japanese

Promotional Transformation of Monadic Programs
Zhenjiang Hu; Hideya Iwasaki
Proc. Fuji International Workshop on Functional and Logic Programming (FLOPS 1995), 196-210, Jul. 1995, Peer-reviwed
International conference proceedings, English

Derivation of Algorithms by Introduction of Generation Functions
Liangwei Xu; Hideya Iwasaki; Masato Takeichi
New Generation Computing, SPRINGER VERLAG, 13, 1, 75-98, Dec. 1994, Peer-reviwed, A specification is a mathematical description of the intent we want a program to behave, while an algorithm is a formal description of a program that satisfies the specification. When we want to write an algorithm by defining data domians and functions over these domains, it is common to use recursion equations for function definitions. However, recursion equations lack imaginability such as existential quantifiers in predicate calculus. In this paper we show how executable algorithms are derived from specifications written in ordinary set-theoretic formulas, and illustrate it by deriving several kinds of sorting algorithms as well as a graph algorithm.
Scientific journal, English

Design and Implementation of a Kernel with User-Definable Objects
岩崎英哉; 竹内幹雄
情報処理学会論文誌, Information Processing Society of Japan (IPSJ), 34, 8, 1752-1761, Aug. 1993, Peer-reviwed, This paper proposes a small "kernel" named "TK800" on the Transputer network for implementing parallel symbolic processing languages. The TK800 kernel provides rather high level features such as asynchronous inter-thread communication and dynamic thread creation. One of the most significant features is its heap management with garbage collection, which is designed for symbolic processing languages. TK800 kernel predefines the formats of some commonly used object types. In addition, it provides object types which can be defined by the user program. To define an original object type, in most cases, the programmer has only to decide its kind and define some macros for the defined types mechanically. TK800 kernel has the responsibility to collect garbages in the heap area filled by predefined and user-defined objects. The internal configuration of the kernel and an implementation of a parallel functional language are also discussed.
Scientific journal, Japanese

マルチプロセッサ Unix マシン上における並列言語処理系の実装法の検討
岩崎英哉
情報処理学会論文誌, Information Processing Society of Japan (IPSJ), 33, 11, 1351-1360, Nov. 1992, Peer-reviwed, 本論文では 並列処理言語の処理系をUnix系共有メモリ型マルチプロセッサ計算機上に実装する際に直面するいくつかの問題点について議論する.ここでは マルチューザの下でCPU資源を使う環境を想定する・さらに 並列処理言語の実際例を示し 考察も加える 実現例を示すのは 並列性言語仕様として持つLisp方言mutilispである.従来のUnixでは システムコールの重さ・機能そのものや機能面の細かさ 並列性記述のためのライブラリが単一プロセッサ向きである点などが マルチプロセッサにおける処理系作成上の問題点となる.mutilispではインタプリタ本体で効率的に解決するのが困難な問題については これをインタプリタ上で動いているLispプログラムに通知する機構を導入し そのプログラムに処置を委ねる という解決法をとる.その結果 問題解決のためには 上位部の特定のプログラム間の関係のみに注目すればよくなり たとえばCPUの放棄も容易に実現でき 処理系の柔軟性が向上することになる。また 本論文では 処理系の性能についても簡単にふれ mutilispでのアプローチが有効であることを示した.本論文で提案する手法は 実行時の動的スケジューリングをおこなうシステムで有効であり 多くの言語処理系に対して応用が可能である.
Scientific journal, Japanese

mUtilisp: a Lisp Dialect for Parallel Processing
Hideya Iwasaki
Proc. US Japan Workshop on Parallel Lisp, Lecture Notes in Computer Science 441, SPRINGER, 316-321, Jun. 1990, Peer-reviwed
Scientific journal, English

Lispにおける並列動作の記述と実現
岩崎英哉
情報処理学会論文誌, 28, 5, 465-470, May 1987, Peer-reviwed
Scientific journal, Japanese

Optimizing Vertex-centric Parallel Graph Processing using Constraint Solver
森畑 明昌; 江本 健斗; 松崎 公紀; 胡 振江; 岩崎 英哉
日本ソフトウェア科学会, 18 Sep. 2017, 日本ソフトウェア科学会大会論文集, 34, 415-429, Japanese, 0913-5391, 40021462421

Intermediate Representation and Code Generator for Frameworks for Vertex-centric Graph Computation
松崎 公紀; 岩崎 英哉; 江本 健斗; 胡 振江; 森畑 明昌
日本ソフトウェア科学会, 18 Sep. 2017, 日本ソフトウェア科学会大会論文集, 34, 493-502, Japanese, 0913-5391, 40021462571

Rubyに対するGradual typingの導入に向けて
丹治将貴; 中野圭介; 岩崎英哉
Jan. 2017, 第58回プログラミング・シンポジウム予稿集

Concurrent Operations on Splay Trees
江本 健斗; 松崎 公紀; 胡 振江; 森畑 明昌; 岩崎 英哉
日本ソフトウェア科学会, 07 Sep. 2016, 日本ソフトウェア科学会大会論文集, 33, 227-242, Japanese, 0913-5391, 40021053340

Using Hardware Transactional Memory for Efficiently Solving Graph Problems
小林 哲; 佐藤 重幸; 岩崎 英哉
近年，ハードウェアトランザクショナルメモリ（HTM）を搭載したCPUが市場にリリースされてきている．HTMのような投機的並列実行は，グラフアルゴリズムの並列処理に有効であることが知られている．そのため，HTMをグラフ問題の並列処理に利用することは有用と考えられる．しかし，現実的なグラフ問題の並列処理におけるトランザクションは，グラフの探索と更新をアトミックに行う必要があるため長くなりやすい．HTMではハードウェアの制限によって，このようなトランザクションを効率的に実行することは難しい．この問題を解決するため，本発表では，HTMのトランザクションを短縮する方法を提案する．提案方法では，計算処理とグラフの探索部分をトランザクションの外に出し，グラフの更新だけをトランザクション内で実行する．本発表では，HTMとしてIntel HaswellのRestricted Transactional Memoryを，グラフ問題としてDelaunay Mesh Refinementを取り上げ，提案する方法をpthreadsのmutexによる実装と比較して評価を行った．Nowadays, commodity processors are equipped with hardware transactional memory (HTM). Speculative parallel execution, which HTM adopts, is known to bring a performance gain in a wide range of graph algorithms. Therefore, the application of HTM to parallel graph processing seems promising. However, transactions in parallel graph processing for practical graph problems tend to be long because both graph traversal and updating have generally to be atomic. Executing such transactions efficiently is difficult because of hardware restrictions of HTM. To resolve this problem, we propose a method for shortening transactions of HTM. It makes calculation and graph traversal migrate from transactions and performs only graph updating within transactions. In this study, we use the Restricted Transactional Memory, which is a HTM functionality of the Intel Haswell architecture, and deal with Delaunay Mesh Refinement as an example graph problem. We evaluate the proposed method by comparing it with mutex locks in Phreads., 02 Jun. 2015, 情報処理学会論文誌プログラミング（PRO）, 8, 1, 16-16, Japanese, 1882-7802, 170000147333, AA11464814

A Deadline I/O Scheduler Equipped with Low Priority Assignment
Narimichi Takamura; Tomoharu Ugawa; Hideya Iwasaki
The availablity of web services has been incresingly demanded. To achieve high availablity, database servers used in the backends of web services have to respond in a low latency. Maintenance operations (e.g., deleting log files and mining data) executed by an operator may raise a pressure on I/O subsystem, which increases the latency of database processing. To solve this problem, it is desired to execute maintenance operations in low priority. However, the deadline I/O scheduler, which is recommended for database servers on Linux cannot deal with priorities for I/O operations. In this research, we have extended the deadline I/O scheduler to enable us to assign low priority to a process, which is inherited to the children. Our I/O scheduler can suppress the increase of latency by executing the maintenance operations at low priority. We evaluated the usefulness of our I/O scheduler on a database server. While in the deadline I/O scheduler, maintenance operations degraded the throughput of database processing down to less than 30%, in our I/O scheduler they degraded that down to at most 75% by assigning low priority to maintenance operations., Information Processing Society of Japan (IPSJ), 27 Feb. 2014, IPSJ SIG Notes, 2014, 8, 1-10, Japanese, 110009675775, AN10444176

Ruby on Railsにおけるテストケース自動生成の提案と実装'
田代克也; 中野圭介; 岩崎英哉
Mar. 2013, 第93回プログラミング研究発表会, Japanese

高速な復帰が可能なLinuxのスリープ機構の実現
羽田野大理; 岩崎英哉; 鵜川始陽
近年データセンタでは，サーバの消費電力の増大が問題となっている．サーバの消費電力を抑えるには，例えばWebサーバではリクエストを処理し終えたら次のリクエストが到着するまでサーバをスリープさせるという手法が考えられる．しかし，現状のLinuxのスリープ機構はACPIを利用しており，スリープからの復帰に多くの時間がかかるという問題点がある．本研究では，ACPIを利用しないスリープ機構を作成した．このスリープ機構は，システム全体はスリープさせず，一部のデバイスのみをスリープさせ，CPUを簡易低電力状態にする．この方法で，Linuxのスリープを用いた場合と比較して，スリープからの復帰時間を大幅に削減できる事を確認した．, 21 Feb. 2013, 研究報告システムソフトウェアとオペレーティング・システム（OS）, 2013, 14, 1-8, Japanese, 110009550195, AN10444176

An Implementation of Mark-compact Garbage Collection Using Bitmap Marking Technique on Jikes RVM
森川 和哉; 鵜川 始陽; 岩崎 英哉
Jikes RVM上で，ビットマップマーキングを利用したマークコンパクトごみ集めを実装し評価した．マークコンパクトごみ集めで広く使われているLisp 2アルゴリズムでは，オブジェクトの移動処理のために，生きているオブジェクトをアドレス順に2回探索する．本手法は，オブジェクトの生存情報をビットマップを使って保持し，そのビットマップをスキャンすることによって，生きているオブジェクトを探索する．生きているオブジェクトが少ない場合，ビットマップ上ではゼロビットが連続しているため，この探索を高速化することができる．提案するごみ集めの性能をDaCapoベンチマークを用いて評価したところ，プログラムによっては，ヒープの使用率が低い場合に，Jikes RVMに標準で搭載されているマークコンパクトごみ集めよりも優れた結果を示した．We have implemented and evaluated a mark-compact garbage collection using bitmap marking on Jikes RVM. The Lisp 2 algorithm, which is widely used in mark-compact garbage colletion, searches twice for live objects in the address order. Our garbage collection holds the locations of live objects in the bitmap by marking their corresponding bits. Then it scans the bitmap for live objects. In the case where the number of live objects is small, the bitmap can be scanned quickly because it has long sequences of zero bits. According to the results of DaCapo benchmarks, our garbage collection is faster than the one that has been implemented on Jikes RVM, depending on programs and heap usage., 24 Jan. 2013, 情報処理学会論文誌プログラミング（PRO）, 6, 1, 27-27, Japanese, 1882-7802, 110009517218, AA11464814

JavaScriptにおけるプログラム変換の効果
田村知博; 中野圭介; 鵜川始陽; 岩崎英哉
06 Jan. 2012, 情報処理学会夏のプログラミング・シンポジウム報告集, 2011, 19-26, Japanese, 201202208058098881

夏のプログラミングシンポジウム
岩崎英哉; 川中真那; 小出洋; 田中哲朗; 松崎公紀; 三廻部大
06 Jan. 2012, 第53回プログラミング･シンポジウム予稿集, 2012, 2012, 47-48, Japanese, 170000071246

Time Contraction : Simplifying Locality Optimization for Stencil Computation
佐藤 重幸; 岩崎 英哉
[日本ソフトウェア科学会], 27 Sep. 2011, 日本ソフトウェア科学会大会論文集, 28, 1-16, English, 0913-5391, 40020660355, AN10158574

UECFS:SSDとHDDを併用して高速なファイルアクセスを実現するファイルシステム
五味真幹; 鵜川始陽; 岩崎英哉
07 Jan. 2011, 第52回プログラミング･シンポジウム予稿集, 2011, 125-132, Japanese, 170000076314

Implementation and Evaluation of Generational Mostly-copying GC in Ruby VM
永原 治; 鵜川 始陽; 岩崎 英哉
近年，Rubyによる大規模アプリケーションの開発が行われるようになってきている．大規模なアプリケーションの特徴として，大量のデータを扱い長時間動作し続けるという特徴があげられる．既存のRuby処理系は保守的マークスイープ方式でごみ集め（GC）をしているが，このような特徴を持つアプリケーションでは，世代別コピーGCでGCの時間を短縮できることが知られている．しかし，Ruby処理系には保守的GCを前提に作られている部分があり，移動できないオブジェクトが多くある．そのため，通常のコピーGCは実現できない．そこで，移動できないオブジェクトが存在しても，コピーGCを実現できるMostly-Copying GCを用いることにした．Mostly-Copying GCでは，ヒープを固定長のブロックに分割する．我々のGCでは，ブロックごとに世代を持たせる．マイナGCでは，新世代にある移動できるオブジェクトを旧世代に移動させるだけでなく，生存オブジェクトの多いブロックは，ブロックごと旧世代に含める．これにより移動できないオブジェクトも旧世代に移すことができる．Recently, large-scale applications have come to be developed in Ruby. A large-scale application tends to treat a large amount of data and to keep working for a long time. While the Ruby VM has the conservative mark-sweep GC, it is known that the time spent on GC in such an application can be reduced by using the generational copying GC. However, we cannot implement the copying GC in the Ruby VM, because part of the VM depends on the conservative GC, and many objects cannot be moved. Therefore we decided to use the mostly-copying GC, which collects garbage by copying only movable objects. The mostly-copying GC divides the heap into equal sized blocks. In our garbage collector, each block has a generation. In minor GC, the collector does not only move movable objects in the new generation to the old generation, but also turns blocks into the old generation if they contain many live objects. This allows immovable objects to get promoted., 22 Sep. 2010, 情報処理学会論文誌プログラミング（PRO）, 3, 4, 61-61, Japanese, 1882-7802, 110007970960, AA11464814

A Checkpoint/Restart Mechanism for Updateing Server Program
MUROI MASAHITO; UGAWA TOMOHARU; IWASAKI HIDEYA
近年，連続的に利用されるシステムが広く普及したことに伴ない，予期せぬ実行時エラーに対処するため，耐故障性に関する研究がなされてきている．耐故障性に関する研究の一つとして，Checkpoint/Restart と呼ばれる手法がある．この手法は正常動作しているプロセスの状態を予め保存しておき，障害発生時に保存しておいた状態を復元する手法である．しかし，通常 Checkpoint/Restart は，同じプログラムを利用するプロセスへ保存した情報を復元するので，バグが原因の障害の場合，同じ障害が発生してしまう．そこで本論文では，バグを修正するなどプログラムの内容を更新したプロセスへ状態を復元することが可能な Checkpoint/Restart 機構の設計と実装を行った．提案機構を利用することで，予め保存した状態を更新後のプログラムを持つプロセスへ復元可能になり，バグの修正に本機構を利用することで，サービスを継続したままプログラムが原因の障害を防げることを確認した．Checkpoint/Restart is a well-known and useful technology for the recovery from a crash due to an unexpected runtime error. This technology first saves the snapshot of a process's running state, and if an error occurs, restores the snapshot to re-construct the state of the running process and resume the execution. However, Checkpoint/Restart usually restores a saved state to a process executing the same program used by the checkpointed process. Thus the same runtime error may occur in the future, since the bug is not fixed. To resolve this problem, this paper described the design and implementation of a Checkpoint/ Restart system which enables users to restore a snapshot to a process executing a program whose bug has been fixed. We have confirmed that the new system are able to prevents the restored process from suffering from the same runtime error., 情報処理学会, 27 Jul. 2010, 研究報告システムソフトウェアと オペレーティング・システム（OS）, 2010, 3, 1-7, Japanese, 0919-6072, 110007995365, AN10444176

Toward an Implementation of Generational Mostly-Copying GC on Ruby VM
永原 治; 鵜川 始陽; 岩崎 英哉
近年，Web アプリケーションをはじめとする Ruby による大規模アプリケーションの開発が行われるようになってきている．大規模なアプリケーションの特徴として，大量のデータを扱い長時間動作し続けるという特徴があげられる．既存の Ruby 処理系は保守的マークスイープ方式でごみ集め （GC） をしているが，このような特徴を持つアプリケーションでは，世代別コピー GC で GC の時間を短縮できることが知られている．しかし，Ruby 処理系には保守的 GC を前提に作られている部分があり，移動できないオブジェクトがあるため，通常のコピー GC は実現できない．そこで，移動できないオブジェクトが存在しても，コピー GC を実現できる Mostly-Copying GC を用いることにした．本研究では，世代別 Mostly-Copying GC の実装による GC 時間の短縮を目標として，Ruby1.9 の VM に Mostly-Copying GC の実装を行い，Ruby on Rails 組み込みの Web サーバなどを対象に移動できないオブジェクトの数やその寿命など世代別 GC の設計に必要なデータ収集を行った．その結果，移動できないオブジェクトの割合は少なくないが，それらは長寿命であるという傾向が分かった．本発表では，これらのデータを基に世代別 Mostly-Copying GC の実装方針と設計について述べる．Recently, large-scale applications, such as web applications, have come to be developed in Ruby. A large-scale application tends to treat a large amount of data and to keep working for a long time. While the Ruby VM has the conservative mark-sweep GC, it is known that the time spent on GC in such an application can be reduced by using the generational copying GC. However, we cannot implement the copying GC on the Ruby VM, because part of the VM depends on the conservative GC, and some objects cannot be moved. Therefore we decided to use the mostly-copying GC, which collects garbage by copying only movable objects. In this research, we aim to reduce the time spent on GC by implementing the mostly-copying GC on the VM of Ruby 1.9. We implemented the mostly-copying GC on the VM and examined the behavior of objects in the heap, such as the ratio of immovable objects and their lifetime, using the VM and a web server program of Ruby on Rails. As a result, we found immovable objects tend to be long-lived though the ratio of them is not small. In this presentation, we present the design of generational mostly-copying GC based on the observation., 16 Mar. 2010, 情報処理学会論文誌プログラミング（PRO）, 3, 2, 49-49, Japanese, 1882-7802, 110007970976, AA11464814

A Load Distribution Library with Method Entrusting for Ruby
川ノ上 哲規; 岩崎 英哉; 鵜川 始陽
プロセスの動的な負荷を分散するための手法として，スレッドマイグレーションがある．しかし，Ruby の処理系はプロセス実行時に C のスタックを使うため，Ruby ではスレッドマイグレーションの実現は難しい．そこで本発表では，メソッド実行委託という負荷分散の機構を提案し，Ruby のライブラリとして実装する．メソッド実行委託とは，メソッドの実行に必要なオブジェクトとクラス定義を，呼び出し時に選んだ別の計算機上のプロセスに動的に転送して実行させることで，負荷を分散する機構である．メソッド実行を請け負うプロセスは，本機構によって自動的に決定されるため，プログラマは請負先の明示的な記述をする必要はない．このライブラリを用いれば，既存の Ruby プログラムに対して，委託用コードを簡単に付加することができ，負荷分散を考慮したプログラムを Ruby で簡潔に記述できる．本発表では，JPEG 圧縮の計算における負荷の分散，クライアント・サーバ型アプリケーションにおけるサーバプロセスの負荷分散をするプログラムを用いて，提案機構の有効性についても述べる．Thread migration is a well-known technique for load balancing. However, since a RubyVM uses a C stack in runtime, it is difficult to implement a thread migration on Ruby. To cope with this problem, we propose a load distribution framework named "method entrusting" and implemented it as a library. The method entrusting dynamically chooses another process on another computer and entrust the process with a method invocation by transferring objects and class definitions, if necessary, that are indispensable for the invocation. The framework automatically selects an appropriate process that contract the method execution. Thus, programmers are not required to specify the process explicitly in their programs. This library enables programmers to easily add codes for method entrusting into existing Ruby programs and to easily achieve load balancing. In this presentation, we also show the effectiveness of this framework with a program for JPEG compression and a program for load distribution on server processes in a client-server application., 28 Aug. 2009, 情報処理学会論文誌プログラミング（PRO）, 2, 4, 66-66, Japanese, 1882-7802, 110007970922, AA11464814

並列計算パターン (スケルトン) による並列プログラミング
岩崎英哉; 胡振江
Dec. 2008, 情報処理, 49, 12, 1385-1394, Japanese, Introduction other

スケルトン並列プログラミング
胡振江; 岩崎英哉
Oct. 2005, 情報処理, 46, 10, 1158-1162, Japanese, Introduction other

助っ人：構成的な並列スケルトンによる並列プログラミングライブラリ
松崎 公紀; 明石 良樹; 江本 健斗; 岩崎 英哉; 胡 振江
並列プログラミングにおける, 通信, 同期, 資源の配置などの問題を解消する一つのパラダイムとして, スケルトン並列プログラミングが提案されている. 我々は, 並列スケルトンライブラリ「助っ人」を開発してきた. 助っ人の特徴としては, (1) 分散データ構造として, リスト, 木, 二次元配列をサポートしていること, (2) 構成的アルゴリズム論による最適化機構, が挙げられる. 本論文では, 具体例を交えて, 本ライブラリを紹介する., 日本ソフトウェア科学会, 2005, 日本ソフトウェア科学会大会講演論文集, 22, 0, 320-333, Japanese, 130004638879

A Parallel Skeleton Library in C++ with Optimization Mechanism
Akashi Yoshiki; Matsuzaki Kiminori; Iwasaki Hideya; Kakehi Kazuhiko; Hu Zhenjiang
Skeletal parallel programming enables programmers to build a parallel program from ready-made components called skeletons (parallel primitives) for which efficient implementations are known to exist, making both the parallel program development and the parallelization process easier. Parallel programs in terms of skeletons are, however, not always efficient. To overcome this problem and make the skeletal parallel programming more practical, this paper proposes a new parallel skeleton library in C++. This system have an optimization mechanism which transforms successive calls of parallel skeletons into a single function call with the help of fusion transformation. This paper describes the implementation of the skeleton library and reports the effects of the optimization., Japan Society for Software Science and Technology, 2004, Conference Proceedings of Japan Society for Software Science and Technology, 21, 0, 46-46, 1349-3515, 130005006607

A Customizable Toolkit for Dependable Cluster-based Internet Servers
Sugiki Akiyoshi; Kono Kenji; Iwasaki Hideya; Masuda Takashi
インターネットサーバでは，提供するサービスに対する高いディペンダビリティが求められている．そのため，可用性・信頼性・管理容易性等，お互いにトレードオフの関係にあるディペンダビリティの構成要因を，アプリケーションの特性や目的に応じて適切に調整する必要がある．既存のアプローチでは，特定のサービスに特化した方法でディペンダビリティを達成したきたが，汎用性に欠け，他のサービスにその方法が転用し難いという問題点があった．この問題点を解決するため，本発表では，サーバシステムをいくつかのステージに分割し，アプリケーションの特性に応じてそれぞれの段階をカスタマイズ可能とすることによりディペンダビリティの達成を可能とするようなツールキットを提案し，その実現を示す．, Japan Society for Software Science and Technology, 2003, Conference Proceedings of Japan Society for Software Science and Technology, 2003, 0, 11-11, 1349-3515, 130004638744

Segmented Diffusion Theorem (invited paper)
Zhenjiang Hu; Tomonari Takahashi; Hideya Iwasaki; Masato Takeichi
2002, 2002 IEEE International Conference on Systems, Man and Cybernetics (SMC 02), Hammamet, Tunisia, October 6-9, 2002. IEEE Press.

プログラミング入門者のためのプログラミング言語「若葉」とその処理系
吉良智樹; 並木美太郎; 岩崎英哉
28 Jul. 1999, 情報教育シンポジウム1999論文集, 99, 10, 127-134, Japanese, 170000082005

構成的アルゴリズム論
岩崎英哉
Nov. 1998, コンピュータソフトウェア, 15, 6, 57-70, Japanese, Peer-reviwed, Introduction other

関数プログラムのプロモーション変換のための二手法の関係
岩崎英哉; 胡振江
関数プログラムでは, 関数の間で受け渡されるが最終結果には出現しない中間的なデータ構造を生成しないように, 関数合成をひとつの関数にプロモーションする(融合する)ことが, 効率改善にとって重要である. 補助引数あるいは蓄積引数を持つ関数に関してこの問題を解決するための手法として, "高階catamorphism"を用いる方法と, "媒介型"を導入することによるhylomorphismを用いる方法が研究されている. 本稿は, 補助引数を持つ関数の高階catamorphismによる融合操作は, 媒介型を用いた変換操作の枠組で説明することができることを, 簡単な具体例を通して示す., 社団法人情報処理学会, 26 Mar. 1996, 情報処理学会研究報告. PRO, [プログラミング], 96, 33, 79-84, 0919-6072, 110002929510

Formal Derivation of Parallel Program for 2-Dimensional Maximum Segment Sum Problem
Hu Zhenjiang; Iwasaki Hideya; Takeichi Masato
It has been attracting much attention to make use of list homomorphisms in parallel programming because they ideally suit the divide-and-conquer parallel paradigm. However, they are usually treated rather informally and ad-hoc in the development of efficient parallel programs. This paper reports a case study on systematic and formal development of a new parallel program for the 2-dimensional maximum segment problem. We show how a straightforward, and "obviously" correct, but quite inefficient solution to the problem can be successfully turned into a semantically equivalent "almost list homo..., Information Processing Society of Japan (IPSJ), 26 Mar. 1996, IPSJ SIG Notes, 96, 33, 73-78, English, 110002929509

Cheap Tupling Transformation
Zhenjiang Hu; Hideya Iwasaki; Masato Takeichi
1996, Technical Report METR 96-08, University of Tokyo. October 1996

Deriving Algorithms on Recursive Relation
Xu Liangwei; Takeichi Masato; Iwasaki Hideya
Relation, endowed with many mathematical niceties, is suitable for describing both the programming specilications and the implementations. Being regarded as a logic formula between input and output values, a relation serves a specification. Being regarded as a composition of some other relations which bend to a special recursive definition scheme, a relation serves an implementation. In this paper, we introduce a recursive definition scheme of relations. We show that the parallel algorithmic model GAMMA(Γ) is a special case of our scheme. We also give some methods of deriving GAMMA programs..., Information Processing Society of Japan (IPSJ), 18 Mar. 1994, 情報処理学会研究報告. 記号処理研究会報告, 94, 31, 17-24, English, 110002929460

Catamorphismに基づく関数プログラムの変換
胡振江; 岩崎英哉; 武市正人
Accumulationとは,構造を持つデータに対する計算を,途中経過を保持しつつ進めていく方法であり,逐次・並列を問わず,効率の良いプログラムの設計・記述によく用いられる.本論文では,Accumulationを定式化するために,従来のCatamorphismの考えを拡張した高階Catamorphismを提案する.また,高階Caramorphismを用いて記述されたプログラムの実行効率を改善するための,基本的な変換定理(プロモーション定理)を示す.さらに,具体的な変換手順を,いくつかの例とともに示す., 社団法人情報処理学会, 09 Mar. 1994, 情報処理学会研究報告. [プログラミング-言語基礎実践-], 94, 21, 49-56, 0919-6072, 110002929444

Catamorphism Based Transformation of Functional Programs
Hu Zhenjiang; Iwasaki Hideya; Takeichi Masato
Accumulations are operators on structured object that proceed their computation on each element of the object keeping some intermediate results.Accumulations are widely used in the design of efficient sequential and parallel programs.The purpose of this paper is to deal with the transformation on accumulations so that more efficient programs can be derived.We formulate accumulations by means of higher order catamorphisms and propose a promotion theorem for accumulations.Some examples are given to explain our method., The Institute of Electronics, Information and Communication Engineers, 09 Mar. 1994, IEICE technical report. Theoretical foundations of Computing, 93, 496, 49-56, English, 110003207093

情報科学の基礎－新しい情報リテラシをめざして－
山口和紀; 岩崎英哉
Japanese, Joint work, 昭晃堂, Apr. 2006

エンサイクロペディア情報処理 改訂版
情報処理学会編
Japanese, Joint work, オーム社, 2000

エンサイクロペディア情報処理
情報処理学会編
Japanese, Joint work, オーム社, 1994

ページ遷移・レイアウト・スクリプトを分離した Web アプリケーション記述システム
廣田幸一; 岩崎英哉
Public symposium, Japanese, 第9回プログラミングおよびプログラミング言語ワークショップ (PPL'2007), 日本ソフトウェア科学会 第9回プログラミングおよびプログラミング言語ワークショップ (PPL'2007)
Mar. 2007

Improving Sequence を第一級の対象とする Scheme コンパイラ
高野保真; 岩崎英哉
Public symposium, Japanese, 第8回プログラミングおよびプログラミング言語ワークショップ (PPL'2006), 日本ソフトウェア科学会 第8回プログラミングおよびプログラミング言語ワークショップ (PPL'2006), 大津
Mar. 2006

ディペンダブルなインターネット・サーバを実現するクラスタ用ミドルウエアの基本設計
杉木章義; 河野健二; 岩崎英哉; 益田隆司
Public symposium, Japanese, 先進的計算基盤システムシンポジウム (SACSIS 2003), 情報処理学会 先進的計算基盤システムシンポジウム (SACSIS 2003)
May 2003

需要変化に動的に対応するミラーサーバの管理基盤
揚妻匡邦; 河野健二; 岩崎英哉; 益田隆司
Oral presentation, Japanese, 日本ソフトウェア科学会 第6回プログラミングおよび応用のシステムに関するワークショップ (SPA'2003)
Mar. 2003

不均等データ上における汎用的並列スケルトン s-diff の提案
高橋知成; 胡振江; 岩崎英哉
Oral presentation, Japanese, 日本ソフトウェア科学会 第4回プログラミングおよびプログラミング言語ワークショップ (PPL'2002)
Mar. 2002

C言語上のスケルトン並列プログラミングシステム
白沢楽; 胡振江; 岩崎英哉
Oral presentation, Japanese, 日本ソフトウェア科学会 第5回プログラミングおよび応用のシステムに関する ワークショップ (SPA'2002)
Mar. 2002

プログラム設計を支援する学習環境 Soegi
松崎公紀; 岩崎英哉
Public symposium, Japanese, 情報処理学会 夏のプログラミング・シンポジウム 「プログラミングの鉄人---プログラミングの技」報告集
Aug. 2001

ACM

情報処理学会

日本ソフトウェア科学会

システムソフトウェアのための安全性と記述性に優れた領域特化言語とその構成法
岩崎 英哉; 中山 泰一
日本学術振興会, 科学研究費助成事業, 明治大学, 基盤研究(C), 23K11055
01 Apr. 2023 - 31 Mar. 2026

大規模グラフを対象とする並列分散処理プログラムのプログラム変換技法に基づく開発手法の確立
岩崎英哉
01 Apr. 2019 - 31 Mar. 2021

Lightweight and Modular JavaScript System for Internet of Things
Ugawa Tomoharu
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, Kochi University of Technology, Grant-in-Aid for Scientific Research (C), We developed lightweight JavaScript virtual machine (VM) suitable for embedded systems used in Internet of Things (IoT). Our approach was to generate a VM of a subset of JavaScript specialised for each application automatically. Our achievements include followings. (1) The mechanism and optimisation algorithms to generate a specialised VM that accepts restricted datatypes as operands of operators. (2) A compacting garbage collection algorithm and a verification method of its implementation. (3) A model checking library to check behaviour of algorithms on weak memory consistency model CPUs. We implemented those results in a JavaScript VM generator eJSTK., 16K00103
01 Apr. 2016 - 31 Mar. 2019

大規模グラフ並列処理のための代数的構造に基づく理論基盤とプログラム開発基盤の構築
岩崎英哉
01 Apr. 2014 - 31 Mar. 2018

Memory Management for Managed Runtimes in Embedded Systems on Multi-Core and Many-Core Processors
Ugawa Tomoharu; IWASAKI Hideya
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, Grant-in-Aid for Scientific Research (C), In this research, we developed a garbage collection (GC) that is suitable for managed runtimes in embedded systems on multi-core and many core processors.The main results of this research are the following. (1) We implemented an existing concurrent copying GC, which is suitable for real-time applications. We identified problems on the GC algorithm and proposed solutions for them. (2) We developed a novel concurrent compacting GC based on the concurrent copying GC. (3) We developed a technique to reduce energy consumption by GC. We developed a program analysis tool for bug detection., 25330080
01 Apr. 2013 - 31 Mar. 2016

実用的ウェブアプリケーション開発を支援するサーバサイドＪａｖａＳｃｒｉｐｔ処理系
岩崎英哉
01 Apr. 2011 - 31 Mar. 2014

多様な形態の密結合マルチコアアーキテクチャ向け並列プログラミングシステム
岩崎英哉
01 Apr. 2008 - 31 Mar. 2011

Development of a Parallel Skeleton Library for rich set of data types withoptimization mechanism
IWASAKI Hideya; HU Zhenjiang
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, The University of Electro-Communications, Grant-in-Aid for Scientific Research (C), This research aims to develop a new practical parallel skeleton library that helps programmers write an efficient parallel program as if it were a sequential one. In skeletal parallel programming, typical patterns of parallel processing are abstracted in parallel skeletons. Examples of parallel skeletons includes map that applies the same function to each element in a list, reduce that collapses a given list into a single value using an associative binary operator, and scan that accumulates all intermediate results of reduce in a list. Each parallel skeleton hides parallel behavior in its implementation, thus programmers need not be involved in the details of parallelization. In this research, we have developed a new skeleton library called SkeTo (Skeleton library in Tokyo). SkeTo is now available as a free software via the page http://www. ipl. t.u-tokvo.ac. jp/sketa. Main features of SkeTo that cannot be seen in other libraries are as follows. 1)SkeTo supports rich set of data types including list, matrix, binary tree and rose tree. 2)SkeTo is implemented in C++ without syntactic extensions for parallel skeletons. Thus programmers who are familiar with C++ have no problem in using the SkeTo library. 3)Based on the theory of Constructive Algorithmics, SkeTo provides optimization mechanism that fuses successive skeleton calls into a single call., 17500021
2005 - 2006

需要変化に動的に対応するインターネットサービスの自己組織化サーバ群による実現
益田 隆司; 河野 健二; 岩崎 英哉
日本学術振興会, 科学研究費助成事業, 電気通信大学, 基盤研究(C), 本研究は,クライアントからの需要に応じて,サーバの数や配置に関する自己組織化を適切に行い,常に最適なサーバ構成を実現するような基盤ソフトウェア技術を確立することを目的とする.本研究の目的を達成するためには,サーバ側の基本機構,およびクライアント側におけるサーバ選択の基本機構を両方を確立しなければならない.今年度は,主にサーバ側の基本機構について研究を行い,以下のような成果を得ることができた. ・サーバ配布機構の実現 モバイルコード技術を用いて,サーバおよびコンテンツを効率よく配布するための実装技術を開発した. ・サーバの最適配置手法の確立 動的な負荷変動に応じて,サーバの配布・回収の方針を定めるアルゴリズム,負荷の分布に応じて最適な配置を可能とするアルゴリズムを設計し,シミュレーションによりその効果を確認し,実インターネット環境への実装を行った. ・デイペンダブルなサーバの構成方法の提唱 「信頼できる」デイペンダブルなサーバを構成するためのソフトウェア的構成方法について検討し,サーバ用ツールキットを試作し,ある程度の効果を確認した., 15500034
2003 - 2004

Development of Theoretical Basis and Practical Implementation of a new Skeletal Parallel Programming System
IWASAKI Hideya; HU Zhenjiang
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, The University of Electro-Communications, Grant-in-Aid for Scientific Research (C), Parallel programming has proved to be difficult, requiring expert knowledge of both parallel algorithms and hardware architectures to achieve good results. Skeletal parallel programming enables programmers to build a parallel program from ready-made components (parallel skeletons) for which efficient implementations are known to exist, making both the parallel program development and the parallelization process easier. This research aims to develop both theoretical basis and practical programming environment system for skeletal parallel programming. Through this research, we have achieved the following results. 1)We have developed a new skeleton that abstracts a good combination of primitive parallel skeletons for recursive data structures such as lists and binary trees. 2)We have developed an optimization rules that fuses two successive calls of skeletons, based on the idea of constructive algorthmics. 3)We have developed a practical skeletal library in C++ and MPI that can be used in general parallel environments. Our library has the following characteristic features that have not implemented in existing libraries. a)The library provides accumulate skeleton that abstracts typical form of recursive functions. b)The library implements fusion transformation that avoids unnecessary intermediate data structures. c) The library has no syntactic extensions that sacrifice generality of C++., 15500020
2003 - 2004

Computer Supported Learning Environment of Programming, Documentation and Presentation for Novice Programmers
IWASAKI Hideya; NAMIKI Mitarou
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, Grant-in-Aid for Scientific Research (C), Standing on the conviction that programming, documentation and presentation are closely related in daily activities, this research aims to propose a computer supported learning environment for novice programmers. The environment supports to learn skills from programming to presentation effectively, together with logical thinking faculties. In this research, we developed and combined various technologies including programming methodology, programming languages and systems, and applications of natural language processing. Our contributions are summarized as follows. 1. Learning environment for novice programmers We constructed an environment that supports learning of program design, coding, and simple documentation. Also we implemented another environment that runs within browsers using Java By this learning environment, users can enjoy debugging supports for both syntax errors and runtime errors. 2. Support for programming From the viewpoint of programming methodology, we put our focus on skeleton programming in which programmers are encouraged to build a program from ready-made components (skeletons). We con structed a system for skeleton programming on top of basic studies of skeletal programming. 3. Support for documentation We developed an algorithm to detect and correct possible homonym errors within Japanese texts and implemented this algorithm as a proofreading tool which enables users to prepare high-quality documents. In addition, we designed and implemented a system that unifies both programming and document preparation languages, which enables users to prepare desired documents effectively. 4. Support for presentation We developed a system that automatically generates presentation sheets from a given text. The system combines some natural presentation techniques such as keywords extraction, division into single sentences, and so on., 12680330
2000 - 2001

Implementation of Program Calculator System
TAKEICHI Masato; IWASAKI Hideya; HU Zhenjiang
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, The University of Tokyo, Grant-in-Aid for Scientific Research (B), Our research aims at collaborating with Oxford group for designing a practical program transformation system based on Constructive Algorithmics which establishes a methodology for practical transformation systems. We had proposed a Technique for implementing transformation based on algebraic rules which lead to formulation of transformation algorithms and we implemented the system as our research project. Our system deals with fusion transformation which is effectively used for functional programs. The final stage of this research conducted this year finishes implementation of the system HYLO with evaluation using benchmark programs. The result shows practical effectiveness of the constructive transformation system based on Constructive Algorithmics., 11694130
1999 - 2001

Implementation of Constructive Parallel Programming Models
TAKEICHI Masato; IWASAKI Hideya; HU Zhenjiang
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, The University of Tokyo, Grant-in-Aid for Scientific Research (B), Our research aims at implementing parallel programming models based on Constructive Algorithmics which establishes a methodology for practical transformation systems. We had proposed a technique for parallelization transformation based on algebraic rules which leads to formulation of transformation algorithms and we implemented the system as our research project. Our models deal with so-called 'Diffusion' transformation which is effectively used for parallelizing sequential programs. The final stage of this research conducted this year finishes implementation of the system using MPI library with evaluation using benchmark programs. The result shows practical effectiveness of the constructive parallelizaion system based on Constructive Algorithmics., 11480065
1999 - 2001

Implementation of a Program Calculation System
TAKEICHI Masato; ONOUE Yoshiyuki; TANAKA Tetsuro; HU Zhenjiang; TAKANO Akihiko
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, The University of Tokyo, Grant-in-Aid for Scientific Research (B), Our research aims at implementing a program calculator based on Constructive Algorithmics which establishes a methodology for practical transformation systems. We had proposed a technique for program transformation based on algebraic rules which leads to formulation of transformation algorithms and we implemented the HYLO calculator system as our research project. Our calculator deals with fusion transformation which is effectively used in functional programs. The final stage of this research conducted this year finishes implementation of the HYLO system with evaluation using benchmark programs. The result shows practical effectiveness of the calculation system based on Constructive Algorithmics. The HYLO system can be used through the WEB page., 10558041
1998 - 2000

一般的な再帰構造をもつ関数プログラムの融合変換とその実用化
岩崎 英哉
日本学術振興会, 科学研究費助成事業, 東京大学, 特定領域研究(A), 本年度は,主として次のような研究を進めた. 1. 融合と組化という二つのプログラム変換手法を有効に組合わせることによる,系統的な変換の実現. 2. 相互再帰の定式化という前年度の研究成果を実働システムとして役立てるための,データ構成子の抽象化手法の検討. 前者に関する主要な成果は,複数の独立したプログラム変換手法,具体的には融合(Fusion)と組化(Tupling)を順番に適用することにより,プログラムを効率のよいものへ系統的に変換可能であることを示すことができた点である.この手法を,一/二次元最大部分列和/積問題に適用し,その有効性を確認した. 後者については,構成的アルゴリズム論における代表的な融合定理(酸性雨定理)を適用可能とするための,変換対象関数の静的解析に関して研究を進めた.「色情報」も付加して型検査を行うことにより,従来のアルゴリズムでは抽象化できなかった,相互再帰定義された型のデータ構成子についても解析が可能になるとの見通しを得た. この他,プログラム変換システムを試作段階から実用的な段階へと推し進める研究も行った., 10139210
1998 - 1998

S式指向のプログラミングシステムの構築に関する研究
岩崎 英哉
日本学術振興会, 科学研究費助成事業, 奨励研究(A), 本研究では,Lispの一方言であるUtiLispをベースとしている.本年度は,主として次のような研究を進め,成果を得ることができた. 1. UtiLispの処理系を,インタプリタ本体にはほとんど手を入れず,様々な環境で作動可能し,さらに移植性の高いGUI(Graphical User Interface)を開発する研究を行った.具体的には,Unix環境とWindows環境の双方で作動するようなGUIを具備するUtiLispシステムを構築し,性能・移植性等について良好な結果を得ることができた. 2. Lispのような記号処理言語あるいは関数型言語的な側面と手続き型言語的な側面を併せ持つ初心者入門用言語環境を設計・実現した.このシステムはJava仮想機械へのコンパイラであり,これにより,ネットワーク指向,機種非依存という特長を備えている. 3. 記号処理プログラム・関数プログラムを,より実行効率のよいものに静的に変換するための手法に関する研究を行った.具体的には,複数の独立したプログラム変換手法(融合(Fusion)と組化(Tupling))を順番に適用することにより,プログラムを効率のよいものへ系統的に変換可能であることを示し,一/二次元最大部分列和/積問題に適用してその有効性を確認した., 09780254
1997 - 1998

Program Optimization Based on Constructive Algorithmics
TAKEICHI Masato; HU Zhenjiang; TAKANO Akihiko; TANAKA Tetsuro; IWASAKI Hideya
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, The University of Tokyo, Grant-in-Aid for Scientific Research (C), Our research aims at designing a framework for program optimization based on constructive algorithmics which establishes a methodology for implementing practical transformation systems. We proposed a technique for program transformation based on algebraic rules which leads to formulation of transformation algorithms. Our calculational techniques are tupling, fusion, parallelization etc. all come from constructive basis. The final stage of this research conducted this year finishes our formulation of program transformation along with construction of a prototype system for transforming programs into more efficient ones with evaluation of its effectiveness., 09680326
1997 - 1998

関数プログラムの再帰構造の抽象化とプログラム融合変換に関する研究
岩崎 英哉
日本学術振興会, 科学研究費助成事業, 東京農工大学, 重点領域研究, 構成的手法によるプログラム変換では,プログラムや型定義を数学的な対象として扱い,少数の強力な変換定理を用いてプログラムを効率のよいものに変換していく.本研究では,従来は十分な考察がなされていなかった相互再帰などの複雑な再帰構造を対象とし,その定式化・変換定理などの実用面における考察を行った. そのために,単純再帰の場合の(一引数の)通常の関手の拡張である二項関手(二引数の関手)を用いて相互再帰を定式化するアプローチをとり,次のような成果を得ることができた. ・二項関手への拡張に対応し,Catamorphism,Anamorphism,Hylomorphismなどのプログラム標準形を拡張した. ・この拡張は「自然な」拡張になっているので,従来の単純な再帰の場合の融合変換定理が,同じ形の式を保ったまま成立することが示された. ・単純な再帰関数のtuple(組)は,相互再帰の特殊な場合として捉えることが可能であることが判明した.したがって,同一のデータ構造を複数回辿るのを防ぐのに有効とされる「tupling」と呼ばれる技法(の一部)は,二項関手を用いた相互再帰の枠組の中に統合することが可能である., 09245207
1997 - 1997

Research on Self-evolution Mechanisms of Computer Programs
TAKEICHI Masato; TANAKA Tetsuro; KANEKO Keiichi; IWASAKI Hidaya
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, University of Tokyo, Grant-in-Aid for Scientific Research (B), This project aims at development of the mechanism for self-organization of computer programs. Self-optimizing property of fully lazy evaluation of functional programs is our starting point of this project. Implementation of a partial evaluator based on this approach shows that the idea is promising while much work remains to be done for making it practical. In Addition to this approach, a novel idea for program transformation system has been explored and implemented for evaluation. Although most program transformation systems so far relies on heuristics, our new system is completely mechanical. It is based on hylomorphisms which comes from research on constructive algorithmics. Algorithms for implementation have been developed and the system HYLO is worked out. These results have been made public at international conferences and published in the proceedings., 07458053
1995 - 1996

Implementation of Parallel Functional Programming Systems
TAKEICHI Masato; TANAKA Tetsuro; MATSUOKA Satoshi; IWASAKI Hideya; YONEZAWA Akinori
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, University of Tokyo, Grant-in-Aid for Scientific Research (A), This project aims at development of functional programming systems for parallel computers. Implementation of a parallel functional system Parallel Gofer on the AP1000 computer has been finished and under evaluation. This implementation is based on the Gofer system developed by Mark Jones and accepts any Gofer programs for sequential evaluation. Programs are allowed to include references to extended library functions for parallelization. Several new ideas for this implementation have been published already. One of such ideas is so-called "unboxing" techniques for data construction. This implementation showed that the idea is promising while some optimization should be considered for practical application. Along with this implementation, a novel idea for optimization has been explored and implemented. Although most optimization so far relies on heuristics, our new system is completely mechanical. It is based on hylomorphisms which comes from research on constructive algorithmics. This technique is applicable to sequential and parallel functional programs. These results have been made public at international conferences and published in the proceedings., 06558039
1994 - 1996

構成的手法によるプログラムの効率化に関する研究
岩崎 英哉
日本学術振興会, 科学研究費助成事業, 東京大学, 奨励研究(A), 構成的手法によるプログラム変換では,プログラムや型定義を数学的な対象として扱い,少数の強力な変換定理を用いてプログラムを効率のよいものに変換していく.本研究では,関数プログラムをその対象とし,構成的手法を用いたプログラムの効率化の可能性について考察し,以下のような結果を得た. ・構成的手法においてはcatamorphismと呼ばれる範疇の関数(プログラム)が重要な役割を果たすが,従来のcatamorphismだけでは記述できないようなプログラムに関しても型変換の前処理を施すことによってcatamorphismの枠組に入れることができることを示した. ・上の「型変換」はcatamorphismとは双対の関係にあるanamorphismの範疇に入るものになり,その結果,元の(変換前の)プログラムはcatamorphismとanamorphismの合成,すなわちhylomorphismで表現されることが判明した. ・hylomorphismに対する変換定理を適用しやすくするための,hylomorphismを「再構成」する変換アルゴリズムを確立した. ・従来のcatamorphismを高階関数に拡張するというという「高階catamorphism」の考えは,上で述べた型変換の前処理と密接な関係にあることが判明した. 以上によりhylomorphismが,構成的手法の見地からみた関数プログラムの「標準形」となりうる可能性が示された., 07780227
1995 - 1995

記号処理言語の新しい評価機構の関する研究
岩崎 英哉
日本学術振興会, 科学研究費助成事業, 東京大学, 奨励研究(A), Improving Valueとは,「少しづつ(ある判断基準からみて)改良されていく値の系列」を表現するデータ構造であり,枝苅りに代表される探索問題において不要な探索を回避するのに役立つことが知られている.本研究では,関数型言語をはじめとする「記号処理言語」に関して,Improving Valueを一般化したデータ構造に基づく新たな評価機構の可能性について考察し,以下のような結果を得た. ・探索問題だけではなく,無限リストの長さを扱ったり繰り返し計算をおこなうような場面でImproving Valueが有効であることが判明した.ただし,関数型言語における参照透明性などの「良い性質」をいかに保存してImproving Valueを言語に採り入れるか,という問題点があることもわかった. ・評価機構としては従来のstrictな評価だけでは不十分で,強strict(従来のstrictに相当する)と弱strictという二段階の評価機構が必要であることが判明した. ・本研究費補助金によって購入した計算機を用いて,G-machineと呼ばれる関数型言語の翻訳系を,Inproving Valueを扱うことができるように拡張した. ・Improving Valueによる利点を享受するするためには,プログラムに対する静的な変換(前処理)をおこなうことも重要である.本研究では,構成的手法を用いた関数プログラム変換が実行効率の向上に広く貢献できることを示した., 06780235
1994 - 1994

高機能高品質ソフトウエア構成法の研究
中田 育男; 岩崎 英哉; 湯浅 太一; 斎藤 信男
日本学術振興会, 科学研究費助成事業, 筑波大学, 重点領域研究, 本重点領域研究のA01班は、高機能高品質ソフトウェアは如何にあるべきか、如何に作るべきかを討論、検討するのを目的としている。班の研究集会は9月4〜5日、3月5〜6日の2回を開催し、出席者はそれぞれ11名、9名であった。 岩崎のグループは、高機能高品質プログラムの構成法についてUti Lispを例に考察した。その結果、高機能高品質ソフトウェアを構成する要因として、「ソフトウェアの核部分に一貫した設計思想と十分な機能を持たせて、それをユーザに公開することが重要である」との知見が得られた。Uti Lispの例でいえば自動記憶管理をもつような言語処理系が背後にひかえることにより、信頼性が高くなり、システムの品質も向上した。 斎藤のグループは、ソフトウェアのさまざまな構成要素にパラメタを与えられるように実現し、それをもとにさまざまな要求に応じられるようにすることを目標とし、ソフトウェア構成方法としてはオブジェクト指向構成方法がよいという結論を得た。 中田のグループは、コンパイラ生成系を改良したり、コンパイラ生成系の技術を他のソフトウェアに適用することによって、より高機能なソフトウェアや、より高品質なソフトウェアを、より機械的に構成する方法を研究した。具体的には、拡張1パス型属性交法、GUIのための時相属性交法などを開発した。, 04219103
1992 - 1992

Parallel Evaluation of Functional Programs
TAKEICHI Masato; KANEKO Keiichi; IWASAKI Hideya
Japan Society for the Promotion of Science, Grants-in-Aid for Scientific Research, University of Tokyo, Grant-in-Aid for General Scientific Research (C), We have studied a basic problem in constructing parallel evaluation system which supports functional programming. It is worth noting that recent development in hardware technology makes it practical to implement the evaluator of functional programs. It is true, however, that evaluators of functional languages implemented on conventional hardware run slower than those for procedural languages. In addition to this, it is known that there is a serious problem in evaluating functional programs in a sequential fashion. This is the reason why we study the way to evaluate functional programs in parallel. We discuss parallel functional programming from the programmer's point of view and present novel ideas on implementing functional languages for parallel machines. First of all, we show that simple annotation works effectively to control evaluation order of parallel functional programs. And we extend this idea to make an evaluator for distributed parallel computers such as transputer systems or the Intel Hypercube. We propose a construct to represent recursive environment structures on a processor network, which is an extension to the standard environment structure. Our research concludes with successful experimentation results to support these ideas., 01550278
1989 - 1990