73 this.map = map;
74 }
75
76 @Override
77 public void run() {
78 while (!shouldExit()) {
79 String prefix = "long" + System.currentTimeMillis();
80 for (int i = 0; i < 10; i++) {
81 String key = prefix + " key = " + i;
82 String value = "the value is " + i;
83 map.put(key, value);
84 }
85 }
86 }
87 }
88
89 class SystemGCTask extends Exitable implements Runnable {
90 private long delayMS;
91
92 SystemGCTask(long delayMS) {
93 this.delayMS = delayMS;
94 }
95
96 @Override
97 public void run() {
98 while (!shouldExit()) {
99 System.gc();
100 ThreadUtils.sleep(delayMS);
101 }
102 }
103 }
104
105 public class TestSystemGC {
106 private static final int numGroups = 7;
107 private static final int numGCsPerGroup = 4;
108
109 private static Map<String, String> longLivedMap = new TreeMap<>();
110
111 private static void populateLongLived() {
112 for (int i = 0; i < 1000000; i++) {
113 String key = "all" + " key = " + i;
114 String value = "the value is " + i;
115 longLivedMap.put(key, value);
116 }
117 }
118
119 private static long getDelayMS(int group) {
120 if (group == 0) {
121 return 0;
122 }
123
124 int res = 16;
125 for (int i = 0; i < group; i++) {
126 res *= 2;
127 }
128 return res;
129 }
130
131 private static void doSystemGCs() {
132 ThreadUtils.sleep(1000);
133
134 for (int i = 0; i < numGroups; i++) {
135 for (int j = 0; j < numGCsPerGroup; j++) {
136 System.gc();
137 ThreadUtils.sleep(getDelayMS(i));
138 }
139 }
140 }
141
142 private static SystemGCTask createSystemGCTask(int group) {
143 long delay0 = getDelayMS(group);
144 long delay1 = getDelayMS(group + 1);
145 long delay = delay0 + (delay1 - delay0) / 2;
146 return new SystemGCTask(delay);
147 }
148
149 private static void startTask(Runnable task) {
150 if (task != null) {
151 new Thread(task).start();
152 }
153 }
154
155 private static void exitTask(Exitable task) {
156 if (task != null) {
157 task.exit();
158 }
159 }
160
161 private static void runAllPhases() {
162 for (int i = 0; i < 4; i++) {
163 SystemGCTask gcTask =
164 (i % 2 == 1) ? createSystemGCTask(numGroups / 3) : null;
165 ShortLivedAllocationTask shortTask =
166 (i == 1 || i == 3) ? new ShortLivedAllocationTask() : null;
167 LongLivedAllocationTask longTask =
168 (i == 2 || i == 3) ? new LongLivedAllocationTask(longLivedMap) : null;
169
170 startTask(gcTask);
171 startTask(shortTask);
172 startTask(longTask);
173
174 doSystemGCs();
175
176 exitTask(gcTask);
177 exitTask(shortTask);
178 exitTask(longTask);
179
180 ThreadUtils.sleep(1000);
181 }
182 }
183
184 public static void main(String[] args) {
185 // First allocate the long lived objects and then run all phases.
186 populateLongLived();
187 runAllPhases();
188 if (args.length > 0 && args[0].equals("long")) {
189 runAllPhases();
190 }
191 }
192 }
|
73 this.map = map;
74 }
75
76 @Override
77 public void run() {
78 while (!shouldExit()) {
79 String prefix = "long" + System.currentTimeMillis();
80 for (int i = 0; i < 10; i++) {
81 String key = prefix + " key = " + i;
82 String value = "the value is " + i;
83 map.put(key, value);
84 }
85 }
86 }
87 }
88
89 class SystemGCTask extends Exitable implements Runnable {
90 private long delayMS;
91
92 SystemGCTask(long delayMS) {
93 System.err.println("SystemGCTask with delay " + delayMS);
94 this.delayMS = delayMS;
95 }
96
97 @Override
98 public void run() {
99 while (!shouldExit()) {
100 System.gc();
101 ThreadUtils.sleep(delayMS * 10);
102 }
103 }
104 }
105
106 public class TestSystemGC {
107 private static long endTime;
108
109 private static final int numGroups = 7;
110 private static final int numGCsPerGroup = 4;
111
112 private static Map<String, String> longLivedMap = new TreeMap<>();
113
114 private static void populateLongLived() {
115 for (int i = 0; i < 1000000; i++) {
116 String key = "all" + " key = " + i;
117 String value = "the value is " + i;
118 longLivedMap.put(key, value);
119 }
120 }
121
122 private static long getDelayMS(int group) {
123 if (group == 0) {
124 return 0;
125 }
126
127 int res = 16;
128 for (int i = 0; i < group; i++) {
129 res *= 2;
130 }
131 return res;
132 }
133
134 private static void doSystemGCs() {
135 ThreadUtils.sleep(1000);
136
137 for (int i = 0; i < numGroups; i++) {
138 for (int j = 0; j < numGCsPerGroup; j++) {
139 System.gc();
140 if (System.currentTimeMillis() >= endTime) {
141 return;
142 }
143 ThreadUtils.sleep(getDelayMS(i));
144 }
145 }
146 }
147
148 private static SystemGCTask createSystemGCTask(int group) {
149 long delay0 = getDelayMS(group);
150 long delay1 = getDelayMS(group + 1);
151 long delay = delay0 + (delay1 - delay0) / 2;
152 return new SystemGCTask(delay);
153 }
154
155 private static void startTask(Runnable task) {
156 if (task != null) {
157 new Thread(task).start();
158 }
159 }
160
161 private static void exitTask(Exitable task) {
162 if (task != null) {
163 task.exit();
164 }
165 }
166
167 private static void runAllPhases() {
168 int i = 0;
169 while (i < 4 && System.currentTimeMillis() < endTime) {
170 SystemGCTask gcTask =
171 (i % 2 == 1) ? createSystemGCTask(numGroups / 3) : null;
172 ShortLivedAllocationTask shortTask =
173 (i == 1 || i == 3) ? new ShortLivedAllocationTask() : null;
174 LongLivedAllocationTask longTask =
175 (i == 2 || i == 3) ? new LongLivedAllocationTask(longLivedMap) : null;
176
177 startTask(gcTask);
178 startTask(shortTask);
179 startTask(longTask);
180
181 doSystemGCs();
182
183 exitTask(gcTask);
184 exitTask(shortTask);
185 exitTask(longTask);
186
187 ThreadUtils.sleep(1000);
188 i++;
189 }
190 }
191
192 public static void main(String[] args) {
193 if (args.length > 0) {
194 int timeout = Integer.parseInt(args[0]) * 1000;
195 System.out.println("Running with timeout of " + timeout + "ms");
196 endTime = System.currentTimeMillis() + timeout;
197 }
198 // First allocate the long lived objects and then run all phases.
199 populateLongLived();
200 runAllPhases();
201 }
202 }
|