1/*
2 * Copyright (c) 2010, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/* @test
25 * @bug 6913877
26 * @summary Stress AsynchronousFileChannel.write
27 * @key randomness
28 */
29
30import java.io.*;
31import java.nio.ByteBuffer;
32import static java.nio.file.StandardOpenOption.*;
33import java.nio.channels.*;
34import java.util.Random;
35import java.util.concurrent.CountDownLatch;
36
37public class LotsOfWrites {
38    static final Random rand = new Random();
39
40    /**
41     * Asynchronously writes a known pattern to a file up to a given size,
42     * counting down a latch to release waiters when done.
43     */
44    static class Writer implements CompletionHandler<Integer,ByteBuffer> {
45        private final File file;
46        private final long size;
47        private final CountDownLatch latch;
48        private final AsynchronousFileChannel channel;
49
50        private volatile long position;
51        private volatile byte nextByte;
52
53        private long updatePosition(long nwrote) {
54            position += nwrote;
55            return position;
56        }
57
58        private ByteBuffer genNextBuffer() {
59            int n = Math.min(8192 + rand.nextInt(8192), (int)(size - position));
60            ByteBuffer buf = ByteBuffer.allocate(n);
61            for (int i=0; i<n; i++) {
62                buf.put(nextByte++);
63            }
64            buf.flip();
65            return buf;
66        }
67
68        // close channel and release any waiters
69        private void done() {
70            try {
71                channel.close();
72            } catch (IOException ignore) { }
73            latch.countDown();
74        }
75
76        Writer(File file, long size, CountDownLatch latch) throws IOException {
77            this.file = file;
78            this.size = size;
79            this.latch = latch;
80            this.channel = AsynchronousFileChannel.open(file.toPath(), WRITE);
81        }
82
83        File file() {
84            return file;
85        }
86
87        long size() {
88            return size;
89        }
90
91        // initiate first write
92        void start() {
93            ByteBuffer buf = genNextBuffer();
94            channel.write(buf, 0L, buf, this);
95        }
96
97        @Override
98        public void completed(Integer nwrote, ByteBuffer buf) {
99            long pos = updatePosition(nwrote);
100            if (!buf.hasRemaining()) {
101                // buffer has been completely written; decide if we need to
102                // write more
103                if (position >= size) {
104                    done();
105                    return;
106                }
107                buf = genNextBuffer();
108            }
109            channel.write(buf, pos, buf, this);
110        }
111
112        @Override
113        public void failed(Throwable exc, ByteBuffer buf) {
114            exc.printStackTrace();
115            done();
116        }
117    }
118
119    public static void main(String[] args) throws Exception {
120        // random number of writers
121        int count = 20 + rand.nextInt(16);
122        Writer[] writers = new Writer[count];
123        CountDownLatch latch = new CountDownLatch(count);
124
125        // initiate writing to each file
126        for (int i=0; i<count; i++) {
127            long size = 512*1024 + rand.nextInt(512*1024);
128            File blah = File.createTempFile("blah", null);
129            blah.deleteOnExit();
130            Writer writer = new Writer(blah, size, latch);
131            writers[i] = writer;
132            writer.start();
133        }
134
135        // wait for writing to complete
136        latch.await();
137
138        // verify content of each file
139        boolean failed = false;
140        byte[] buf = new byte[8192];
141        for (int i=0; i<count ;i++) {
142            Writer writer = writers[i];
143            FileInputStream in = new FileInputStream(writer.file());
144            try {
145                long size = 0L;
146                byte expected = 0;
147                int nread = in.read(buf);
148                while (nread > 0) {
149                    for (int j=0; j<nread; j++) {
150                        if (buf[j] != expected) {
151                            System.err.println("Unexpected contents");
152                            failed = true;
153                            break;
154                        }
155                        expected++;
156                    }
157                    if (failed)
158                        break;
159                    size += nread;
160                    nread = in.read(buf);
161                }
162                if (!failed && size != writer.size()) {
163                    System.err.println("Unexpected size");
164                    failed = true;
165                }
166                if (failed)
167                    break;
168            } finally {
169                in.close();
170            }
171        }
172
173        // clean-up
174        for (int i=0; i<count; i++) {
175            writers[i].file().delete();
176        }
177
178        if (failed)
179            throw new RuntimeException("Test failed");
180    }
181}
182